newPaste

#include "Header.h"

class CDetector
{
	long long numero;
	std::string palabra;
	bool request;
	double doub;

	std::string type;
public:
	CDetector(std::string word)
	{
		type = detectar(word);
		if (type == "string")
		{
			palabra = word, numero = NULL, request = NULL, doub = NULL;
		}
		else if (type == "bool")
		{
			palabra = " ", numero = NULL, doub = NULL;
			if (word == "SI")
				request = true;
			else
				request = false;
		}
		else if (type == "long")
		{
			palabra = " ", doub = NULL, request = NULL;
			numero = std::stoll(word);
		}
		else if (type == "double")
		{
			palabra = " ", numero = NULL, request = NULL;
			doub = std::stod(word);
		}
		else if (type == "Desconocido")
		{
			palabra = " ", numero = NULL, doub = NULL, request = NULL;
		}
		else
		{
			palabra = "ERROR :(", numero = NULL, request = NULL, doub = NULL;
		}
	}

	~CDetector() {}

	std::string getType()
	{
		return this->type;
	}

	std::string detectar(std::string word)
	{
		if ((word[0] >= 65 && word[0] <= 122) && (word != "SI" && word != "NO"))
			return "string";
		else if (word == "SI" || word == "NO")
			return "bool";
		else if (word[0] >= 48 && word[0] <= 57)
		{
			if ((double)std::stoll(word) != std::stod(word))
				return "double";
			else if ((double)std::stoll(word) == std::stod(word))
				return "long";
		}
		else return "Desconocido";
	}
};

class CColumna abstract
{

public:
	CColumna() {}
	~CColumna() {}
	virtual void mostrar() {}

};

class CColumnaString : public CColumna
{
	CVector<std::string>* vec;
public:
	CColumnaString() : CColumna()
	{
		vec = new CVector<std::string>();
	}

	~CColumnaString()
	{
		delete vec;
	}

	void agregar(std::string elem)
	{
		vec->addToTree(elem);
	}

	void mostrar(long long i)
	{
		std::cout << vec->getSafer()->at(i) << ',';
	}

	CVector<std::string>* getVec() {
		return this->vec;
	}
};

class CColumnaDouble : public CColumna
{
	CVector<double>* vec;
public:
	CColumnaDouble() : CColumna()
	{
		vec = new CVector<double>();
	}

	~CColumnaDouble()
	{
		delete vec;
	}

	void agregar(double elem)
	{
		vec->addToTree(elem);
	}

	void mostrar(long long i)
	{
			std::cout << vec->getSafer()->at(i) << ',';
	}

	CVector<double>* getVec() {
		return this->vec;
	}
};

class CColumnaBool : public CColumna
{
	CVector<bool>* vec;
public:
	CColumnaBool() : CColumna()
	{
		vec = new CVector<bool>();
	}

	~CColumnaBool()
	{
		delete vec;
	}

	void agregar(bool elem)
	{
		vec->addToTree(elem);
	}

	void mostrar(long long i)
	{

			std::cout << vec->getSafer()->at(i) << ',';
	}

	CVector<bool>* getVec() {
		return this->vec;
	}
};

class CColumnaLong : public CColumna
{
	CVector<long long>* vecx;
public:
	CColumnaLong() : CColumna()
	{
		vecx = new CVector<long long>();
	}

	~CColumnaLong()
	{
		delete vecx;
	}

	void agregar(long long elem)
	{
		vecx->addToTree(elem);
	}

	void mostrar(long long i)
	{
			std::cout << vecx->getSafer()->at(i) << ',';
	}

	CVector<long long>* getVec() {
		return this->vecx;
	}
};

class CFila
{
private:
	std::vector<long long>* vecID;
public:
	CFila()
	{
		vecID = new std::vector<long long>();
	}
	~CFila() {
		delete vecID;
	}

	void ordenarColumnas(long long i, std::vector<CColumnaLong*>*& vecLong, std::vector<CColumnaString*>*& vecString, std::vector<CColumnaDouble*>*& vecDouble, std::vector<CColumnaBool*>*& vecBool)
	{
		vecString->at(0)->getVec()->safe();
	}

	std::vector<long long>* getVectorLong()
	{
		return this->vecID;
	}

};

class CArchivo
{
private:
	CDetector* det;
	long long contLon;
	long long contString;
	long long contDouble;
	long long contBool;
	bool filaInicial;

public:
	CArchivo()
	{
		filaInicial = true;
		contDouble = 0;
		contBool = 0;
		contLon = 0;
		contString = 0;
	}
	~CArchivo() { delete det; }

	void escribirArchivo()
	{
		std::ofstream archivoJoc("ArchivoJoc.txt", std::ios::out);
		if (!archivoJoc.is_open())
		{
			std::cout << "El archivo no se ha podido abrir, verifique el nombre del archivo." << std::endl;
			exit(1);
		}
		std::string linea;
		std::cout << "Ingrese lo que desea ingresar en el archivo: "; std::getline(std::cin, linea);
		archivoJoc << linea;
		archivoJoc.close();
	}

	void leerArchivo(std::vector<CColumnaLong*>*& vecLong, std::vector<CColumnaString*>*& vecString, std::vector<CColumnaDouble*>*& vecDouble, std::vector<CColumnaBool*>*& vecBool, std::vector<long long>*& vec, long long& numFilas)
	{
		std::string nombreArchivo;
		std::cout << "Ingrese el nombre del archivo que desea abrir";
		std::cin >> nombreArchivo;
		std::ifstream archivoJoc(nombreArchivo.c_str(), std::ios::in);
		if (!archivoJoc.is_open())
		{
			std::cout << "El archivo no pudo abrirse, por favor verifique el nombre del archivo.";
			exit(1);
		}
		std::string linea, num;
		while (archivoJoc >> linea)
		{
			int numColumnas = 0;
			std::stringstream ss(linea);
			while (std::getline(ss, num, ','))
			{
				det = new CDetector(num);
				if (filaInicial)
				{
					if (det->getType() == "long")
					{
						vecLong->push_back(new CColumnaLong());
						vecLong->at(contLon)->agregar(std::stoll(num));

						++contLon;
						vec->push_back(1);
					}
					else if (det->getType() == "string")
					{
						vecString->push_back(new CColumnaString());
						vecString->at(contString)->agregar(num);

						++contString;
						vec->push_back(2);
					}
					else if (det->getType() == "double")
					{
						vecDouble->push_back(new CColumnaDouble());
						vecDouble->at(contDouble)->agregar(std::stod(num));

						++contDouble;
						vec->push_back(3);
					}
					else if (det->getType() == "bool")
					{
						vecBool->push_back(new CColumnaBool());
						if (num == "SI")
						{
							vecBool->at(contBool)->agregar(true);
						}else { vecBool->at(contBool)->agregar(false); }

						++contBool;
						vec->push_back(4);
					}
				}
				else {
						switch (vec->at(numColumnas))
						{
						case 1:
							vecLong->at(contLon)->agregar(std::stoll(num));
							++contLon;
							break;

						case 2:
							vecString->at(contString)->agregar(num);
							++contString;
							break;

						case 3:
							vecDouble->at(contDouble)->agregar(std::stod(num));
							++contDouble;
							break;

						case 4:
							if (num == "SI")
							{
								vecBool->at(contBool)->agregar(true);
							}
							else { vecBool->at(contBool)->agregar(false); }
							++contBool;
							break;
						default:break;
						}
						++numColumnas;
				}

			}
			contLon = 0;
			contString = 0;
			contDouble = 0;
			contBool = 0;
			filaInicial = false;
			++numFilas;
		}
		archivoJoc.close();
	}

};

class CDataFrame
{
private:
	std::vector<CColumnaLong*>* vecLong;
	std::vector<CColumnaString*>* vecString;
	std::vector<CColumnaDouble*>* vecDouble;
	std::vector<CColumnaBool*>* vecBool;
	long long numFilas;
	std::vector<long long>* vec;
	long long contLon;
	long long contString;
	long long contDouble;
	long long contBool;
	CArchivo* archivo;
public:
	CDataFrame()
	{
		vecLong = new std::vector<CColumnaLong*>();
		vecString = new std::vector<CColumnaString*>();
		vecDouble = new std::vector<CColumnaDouble*>();
		vecBool = new std::vector<CColumnaBool*>();
		contDouble = 0;
		contBool = 0;
		contLon = 0;
		contString = 0;
		archivo = new CArchivo();
		numFilas = 0;
		vec = new std::vector<long long>();
	}
	~CDataFrame()
	{
		delete vecLong;
		delete vecString;
		delete vecBool;
		delete vecDouble;
		delete archivo;
		delete vec;
	}

	void leerArchivo()
	{
		archivo->leerArchivo(vecLong, vecString, vecDouble, vecBool, vec, numFilas);
	}

	void mostrarColumnas()
	{
		for (long long Fila = 0; Fila < numFilas; ++Fila)
		{
			for (long long numColumnas = 0; numColumnas < vec->size(); ++numColumnas)
			{
				switch (vec->at(numColumnas))
				{
				case 1:
					vecLong->at(contLon)->mostrar(Fila);
					++contLon;
					break;

				case 2:
					vecString->at(contString)->mostrar(Fila);
					++contString;
					break;

				case 3:
					vecDouble->at(contDouble)->mostrar(Fila);
					++contDouble;
					break;

				case 4:
					vecBool->at(contBool)->mostrar(Fila);
					++contBool;
					break;
				default:break;
				}
			}
			std::cout << std::endl;
			contLon = 0;
			contString = 0;
			contDouble = 0;
			contBool = 0;
		}

	}
};

int main()
{
	/*std::map<long long, std::vector<CColumnaLong*>*> mpLong;
	std::map<long long, std::vector<CColumnaString*>*> mpString;

	std::map<long long, std::vector<CColumnaDouble*>*> mpDouble;
	std::map<long long, std::vector<CColumnaBool*>*> mpBool;*/
	/*CArchivo* archivo = new CArchivo();
	archivo->leerArchivo();
	delete archivo;*/

	CDataFrame* df = new CDataFrame();
	df->leerArchivo();
	df->mostrarColumnas();

	std::cin.get();
	std::cin.get();
	delete df;
	return 0;
}