char buffer[256];
    ifstream fi;
    fi.open(INPUT_FILE);
    for(int i=1; i<lineNumber; i++)
    {
        if(fi.eof())
        {
            // ran out of lines before lineNumber, handle the error with output maybe
            fi.close();
            break;
        }
        fi.getline(buffer,sizeof(buffer));
    }
    if(fi.is_open())
    {
        // the next fi.getline will have all the contents of that line
        fi.close();
    }

class Floader{
        stdVector<stdString> loadedData;
public:
        //constructors
        Floader(const char *);
        Floader(){}
        //data manipulation
        void resetData();
        void loadDataFromFile(const char *);
 
        int size();
        stdString getLine(int);
        void showContents();
        void outputToFile(const char *);
        stdString str();
 
 
        stdString& operator[](int num){return loadedData[num];}
        Floader operator=(Floader&);
        Floader operator+(stdString &str){
                loadedData.push_back(str);
                return *this;
        }
 
        stdVector<stdString>& getLoadedData();
 
        //Delete Lines. You can insert as many variables as you want
        //At the end of the arguments, terminate with -1 as the last
        //argument
        void deleteLines(int line ... );
        void deleteLinesContainingCharacters(stdString str);
 
        void loadDataFromString(const char* str);
        //--Look at the implementation file for this function...
        friend stdOstream& operator<<(stdOstream &stream, Floader &ob);
 
 
        void cleanup();
        void cleanupForSoulParser();
};
 
 
//IMPLEMENTATION
 
 
Floader::Floader(const char *fileName){
        loadDataFromFile(fileName);
}
 
 
void Floader::resetData(){
        loadedData.clear();
}
 
void Floader::loadDataFromFile(const char *fileName){
        int i;
        resetData();
        stdString line;
        fstream myFile(fileName);
        for (i=0; myFile.good(); i++) {
                getline(myFile,line);
                loadedData.push_back(line);
        }
 
        myFile.close();
        stdCout << "Process completed\n";
}
 
int Floader::size(){
        return loadedData.size();
}
 
stdString Floader::getLine(int pos){
        return loadedData[pos];
}
 
void Floader::showContents(){
        int i;
        for (i=0; i<loadedData.size(); i++) {
                stdCout << loadedData[i] << "\n";
        }
}
 
 
void Floader::deleteLines(int line ... )
{
        va_list VL;
        va_start(VL, line);
        for (;;) {
                int p= va_arg(VL, int);
                try {
                        if(p<0) 
                                break;
                        else if (p < loadedData.size()) {
                                stdVector<stdString>::iterator alpha;
                                alpha = loadedData.begin();
                                for (int i=0; i<line; i++)        
                                        alpha++;
                                loadedData.erase(alpha);
                        }
                        else
                                throw argument_out_of_bounds(p,INTEGER);
 
                }
                catch (argument_out_of_bounds& error) {
                        error.description();
                }
        }
 
        va_end(VL);
}
 
 
void Floader::outputToFile(const char *filename){
        int i;
        stdOfstream outFile(filename);
        for (i=0; i<loadedData.size(); i++) {
                outFile << loadedData[i] << "\n";
        }
        outFile.close();
}
 
stdString Floader::str(){
        stdString result;
        for (int i=0; i<loadedData.size(); i++) {
                result = result + '\n' + loadedData[i];
        }
        return result;
}
 
stdVector<stdString>& Floader::getLoadedData(){
        return loadedData;
}
 
void Floader::deleteLinesContainingCharacters(stdString str){
        for (int i=0; i<loadedData.size(); i++) {
                if (loadedData[i].find(str) != stdString::npos){
                        loadedData.erase(loadedData.begin()+i);
                        deleteLinesContainingCharacters(str);
                }
        }
}
 
void Floader::cleanup(){
        for (int i=0; i<loadedData.size(); i++) {
                stdString str = loadedData[i];
                str = clearStringFromSpaces(str);
                loadedData[i] = str;
                if( str == "\n" || str.length() <=1 ){
                        loadedData.erase(loadedData.begin() + i);
                        cleanup();
                }
        }
}
 
void Floader::cleanupForSoulParser(){
        for (int i=0; i<loadedData.size(); i++) {
                stdString str = loadedData[i];
                if (str.find(char(OPENING_BRACKET)) == string::npos) {
                        str = clearStringFromSpaces(str);
                        loadedData[i] = str;
                        if( str == "\n" || str.length() <=1 ){
                                loadedData.erase(loadedData.begin() + i);
                                cleanupForSoulParser();
                        }                        
                }
        }
}
 
void Floader::loadDataFromString(const char* str){
        stdStringStream SStream;
        SStream << str;
        stdString line;
        while (SStream.good()) {
                getline(SStream,line);
                loadedData.push_back(line);
        }
 
}
 
//----------------------FRIEND FUNCTIONS----------------------
stdOstream& operator<<(stdOstream &stream, Floader &ob){
        for (int i=0; i<ob.size(); i++) {
                stream << ob[i] <<'\n';
        }
        return stream;
}