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;
}