Exemplo n.º 1
0
Libro::Libro(Libro& unLibro){
	cout << "llamando al constructor de copias" << endl;

	titulo = unLibro.getTitulo();
	codigo=unLibro.getCodigo();

}
Exemplo n.º 2
0
int Servicios::procesarLibro(int indice)
{
	int error = 0;
	SinIndice *listas = SinIndice().getInstancia();

	list<unsigned int> *lista;

	switch(indice)
	{
		case INDICE_AUTORES :lista = listas->getPendientesAutores();break;
		case INDICE_EDITORIALES:lista = listas->getPendientesEditoriales();break;
		case INDICE_TITULOS:lista = listas->getPendientesTitulos();break;
		case INDICE_PALABRAS:lista = listas->getPendientesPalabras();break;
	}

	for (list<unsigned int>::iterator it = lista->begin(); it != lista->end(); it++)
	{
		Libro *libro = 0;
		int error = recuperarLibro((*it), &libro);
		cout <<"Autor: "<< libro->getAutor() <<endl;
		cout <<"Editorial: "<< libro->getEditorial() <<endl;
		cout <<"Titulo: "<< libro->getTitulo() <<endl;
		cout <<"Id: "<< libro->getId() <<endl;
		cout <<"Cant.palabras: " << libro->getCantPalabras() << endl;
		//cout << "Presione ENTER para continuar...." << endl;
		//cin.get();

		switch(indice)
		{
			case INDICE_AUTORES :error = agregarIndiceAutores(libro);break;
			case INDICE_EDITORIALES:error = agregarIndiceEditoriales(libro);break;
			case INDICE_TITULOS:error = agregarIndiceTitulos(libro);break;
			case INDICE_PALABRAS:error = agregarIndicePalabras(libro);break;
		}

		delete libro;
	}

//limpia la lista de ids pendientes de procesar
	switch(indice)
	{
		case INDICE_AUTORES :error = listas->limpiarListaAutores();break;
		case INDICE_EDITORIALES:error = listas->limpiarListaEditoriales();break;
		case INDICE_TITULOS:error = listas->limpiarListaTitulos();break;
		case INDICE_PALABRAS:error = listas->limpiarListaPalabras();break;
	}

	return error;
}
Exemplo n.º 3
0
int main() {

	int opcion = 0;
	int opcionClientes = 0;
	int tempOpcion = 0;
	int tempID = 0;
	int id = 0;
	int idLibros = 0;
	int numItem = 0;
	int cantidad = 0;
	int precio = 0;
	bool continuar = true;
	bool volverMenu = true;
	char estado;
	char tempConfirmacion;
	string nombre = "";
	string apellido = "";
	string direccion = "";
	string titulo = "";
	string autor = "";
	string codigoLibro = "";


	ListaClientes* lista = new ListaClientes();
	ListaLibro* listaLibro = new ListaLibro();


	while(continuar){


		cout << "\n\nBienvenido a Shopping Somewhere\n" << endl;
		cout << "Menú principal:" << endl;
		cout << "1 - Clientes" << endl;
		cout << "2 - Libros" << endl;
		cout << "3 - Órdenes" << endl;
		cout << "4 - Salir\n" << endl;

		cout << "Seleccione una opcion: ";
		cin >> opcion;

		switch(opcion){
		case 1:
			while(volverMenu){
				cout << "\nMenu de clientes:" << endl;
				cout << "1 - Listar Clientes" << endl;
				cout << "2 - Crear Cliente" << endl;
				cout << "3 - Buscar Cliente" << endl;
				cout << "4 - Modificar Cliente" << endl;
				cout << "5 - Eliminar Cliente" << endl;
				cout << "6 - Volver al menu principal\n" << endl;

				cout << "Seleccione una opcion: ";
				cin >> opcionClientes;

				switch(opcionClientes){

					case 1:
						lista->listarClientes();
						break;

					case 2:
						{
							cout << "Creación de clientes\n" << endl;
							cout << "Nombre: ";
							cin >> nombre;

							cout << "Apellido: ";
							cin >> apellido;

							cout << "Dirección: ";
							cin >> direccion;

							Cliente* cliente = new Cliente();
							id++;
							cliente->crearCliente(id,nombre,apellido,direccion);
							lista->agregar(cliente);
						}
						break;

					case 3:
					{
						string nombreCliente = "";
						cout<<"Introduzca el nombre del cliente: "<<endl;
						cin>>nombreCliente;
						int contador = 0;
						string clientes[] = {};

						Cliente* busquedaCliente = lista->getPrimerElemento();

						while(busquedaCliente != NULL){
							clientes[contador] = busquedaCliente->getNombre();
							//cout << cliente[contador] << endl;
							busquedaCliente = busquedaCliente->getSiguienteCliente();
							contador++;
							//cout<<contador<<endl;

						}
						//cout<<nombreCliente<<endl;

						vector<string> myvector(clientes, clientes+(sizeof(clientes)/sizeof(clientes[0])));
						sort(myvector.begin(), myvector.end());
						if(lista->buscar(myvector, myvector.size(), nombreCliente) > -1){
								cout<<"Found "+nombreCliente<<endl;
						}
							else
							{
								cout<<"Not found "+nombreCliente<<endl;
							}


					}
						break;

					case 4:

						lista->listarClientes();
						cout << "\nIntroduzca el numero de cliente a modificar: ";
						cin >> tempOpcion;
						lista->modificar(tempOpcion);
						break;

					case 5:

						lista->listarClientes();
						cout << "\nElige el numero del cliente a eliminar: ";
						cin >> tempID;
						cout << tempID;
						cout << "\nEsta seguro de elimar el contacto (s/n): ";
						cin >> tempConfirmacion;
						if(tempConfirmacion == 's' || tempConfirmacion == 'S'){
							lista->eliminar(tempID);
						}
						break;

					case 6:
						{
							cout <<"Saliendo..." << endl;
							volverMenu = false;
						}
						break;
				}
			}
			break;

			case 2:
				while(volverMenu){
					cout << "\nMenu de Libros:" << endl;
					cout << "1 - Listar Libros" << endl;
					cout << "2 - Crear Libro" << endl;
					cout << "3 - Buscar Libro" << endl;
					cout << "4 - Modificar Libro" << endl;
					//cout << "5 - Cambiar Libro" << endl;
					cout << "5 - Volver al menu principal\n" << endl;

					cout << "Seleccione una opcion: ";
					cin >> opcionClientes;

					switch(opcionClientes){

						case 1:
							listaLibro->listarLibro();
							break;

						case 2:
							{
								cout << "Insercion de nuevo libro\n" << endl;
								cout << "Titulo: ";
								cin >> titulo;

								cout << "Autor: ";
								cin >> autor;

								cout << "Codigo del libro: ";
								cin >> codigoLibro;

								cout << "Cantidad: ";
								cin >> cantidad;

								cout << "Precio: ";
								cin >> precio;
								/*cout << "Dirección: ";
								cin >> estado;*/

								Libro* libro = new Libro();
								idLibros++;
								libro->crearLibro(idLibros, titulo, autor, codigoLibro, 'D', cantidad ,precio);
								listaLibro->agregar(libro);
							}
							break;

						case 4:

							listaLibro->listarLibro();
							cout << "\nIntroduzca el numero del libro a modificar: ";
							cin >> tempOpcion;
							listaLibro->modificar(tempOpcion);
							break;

						/*case 5:

							listaLibro->listarLibro();
							cout << "\nElige el numero del libro a cambiar el estado: ";
							cin >> tempID;
							cout << "\nEsta seguro cambiar el estado (s/n): ";
							cin >> tempConfirmacion;
							if(tempConfirmacion == 's' || tempConfirmacion == 'S'){
								listaLibro->cambiarEstado(tempID);
							}
							break;*/

						case 5:
							{
								cout <<"Saliendo..." << endl;
								volverMenu = false;
							}
							break;
					}
				}
				break;

			case 4:

				cout <<"Saliendo..." << endl;
				continuar = false;
				break;

			default:
				cout <<"'"<< opcion <<"' no es un valor válido" << endl;
				break;
		}
	}

	return 0;
}
void ColeccionLibros::cargarLibro(){
	Libro * lib = new Libro;
	Aparicion * apa = new Aparicion;
	string palabra;
	int parrafos = 0;
	int palabras = 0;

	lib->leer();

	insertar(lib);

	apa->iniciarActuales();

	palabra = apa->leerAparicion(lib);

	while (palabra != "fiiin"){
		
		bool insertado = false;
	
		// Si la palabra que se lee ya existía en el árbol...
		if (diccionario.consultar(palabra)){

			// ... accedemos a la lista de apariciones que ya tenía dicha palabra creada...
			list<Aparicion*> * listaApariciones = diccionario.listaAparicionArbolActual(palabra);
			
			// ... y la insertamos con las restricciones de menor/mayor blablabla...
			list<Aparicion*>::iterator it = listaApariciones->begin();
			for (it = listaApariciones->begin(); it != listaApariciones->end(); it++){


				if (((*it)->devuelveLibro()->codigoisbn() < apa->devuelveLibro()->codigoisbn())
					&& !insertado){
					listaApariciones->insert(it, apa);
					insertado = true;
				}

				else if (((*it)->devuelveLibro()->codigoisbn() == apa->devuelveLibro()->codigoisbn()) 
					&& ((*it)->ncapA() < apa->ncapA())
					&& !insertado) {
					
					listaApariciones->insert(it,apa);
					insertado = true;
				}


				else if (((*it)->devuelveLibro()->codigoisbn() == apa->devuelveLibro()->codigoisbn()) 
					&& ((*it)->ncapA() == apa->ncapA())
					&& ((*it)->nparA() < apa->nparA())
					&& !insertado){
					
					listaApariciones->insert(it,apa);
					insertado = true;
				}

				else if (((*it)->devuelveLibro()->codigoisbn() == apa->devuelveLibro()->codigoisbn()) 
					&& ((*it)->ncapA() == apa->ncapA())
					&& ((*it)->nparA() == apa->nparA())){
					
					delete apa;
					insertado = true;
				}
			}

			if (!insertado && it == listaApariciones->end()){
				listaApariciones->insert(it,apa);
		}

		diccionario.actualizarListaAparicion(palabra, listaApariciones);
		}

		// Si la palabra que se lee NO existía en el árbol..
		else{
			// .. se crea una nueva lista (a la que se le mete la aparición al principio), y ésta al árbol.
			diccionario.insertar(palabra);
			list<Aparicion*> * listaApariciones = new list<Aparicion*>();
			list<Aparicion*>::iterator it = listaApariciones->begin();
			listaApariciones->insert(it,apa);
			
			diccionario.actualizarListaAparicion(palabra, listaApariciones);

		}

		parrafos = apa->totalParrafos();
		palabras = apa->totalPalabras();

		apa = new Aparicion;

		palabra = apa->leerAparicion(lib);
	}
	
	delete apa;

	lib->mostrarLargo();
	cout << parrafos << " párrafos" << endl;
	cout << palabras << " palabras" << endl;
}
void ColeccionLibros::consultar(int isbn){
	Libro * libro = libros.consultar(isbn);

	if(libro == NULL) cout << "ISBN " << isbn << " no encontrado" << endl;
	else libro->mostrarLargo();
}
Exemplo n.º 6
0
int main(int argc, char const *argv[]){
	//Editorial editoriales[30];
	int seleccionMenu;
	bool headerExists = false;
	bool repeat = true;
	bool headerDirty = false;
	bool dirtyHeader = false;
	bool indexExists = false;
	Header header(-1, sizeof(Libro),0,false);
	bool noWrite = false;
	//editorialID nombre Direccion

	//creating index, attempt 2
	ifstream infileLibros("libros.bin",ios::binary);
	ifstream infileIndex("index.bin",ios::binary);
	ifstream infileEditorial("editoriales.bin", ios::binary | ios::in);
	Header jader;
	int aHierro = 0;
	char nombreEditoriales[21][25] = {"Alfaguara", "Algaida", "Almadraba", "Algar", "Almuzara",
	 "Anaya", "Apila","Buen Paso","Bambu","Berenice",
	 "Barcanova","Brosquil","Casals","Bromera",
	 "Coco Books","ComaNegra","Creagem","Edebe","Edelvives","Destino"};
	char direccionEditoriales[21][25] = {"La Canoa","Puerto Rico","Las Hadas","Las Uvas","Villa Olimpica",
	"Kennedy","Kansas","California","Romania","Grecia",
	"Francia","Alemania","Los Tostones","Mexico","Canada",
	"China","Portugal","Chile","Colombia","Venezuela"};

	if(!infileEditorial.good()){
		infileEditorial.close();
		ofstream edit("editoriales.bin", ios::binary| ios::out | ios::trunc);
		Editorial* editor;
		for (int i = 1; i < 21; ++i){
				editor = new Editorial(i,nombreEditoriales[i],direccionEditoriales[i]);
				edit.write(reinterpret_cast<char*>(&editor), sizeof(Editorial));
				delete editor;
		}
		edit.close();
	}else{
		infileEditorial.close();
	}










	if (infileLibros.good()){
		infileLibros.seekg(0);
		infileLibros.read(reinterpret_cast<char*>(&jader), sizeof(Header));
		dirtyHeader = jader.getDirty();
		if (dirtyHeader == true){
			aHierro = 1;
		}
	}

	infileLibros.close();
	infileIndex.close();

	if (aHierro == 1){
		cout<<"Creando Index..."<<endl;
		ifstream Registry("libros.bin", ios::binary);
		Registry.seekg(sizeof(Header));
		Libro bookTemp;
		vector<char*> keys;
		vector<long int> offsets;
		int contadorRegistros= 0;

		while(!Registry.eof()){
			Registry.read(reinterpret_cast<char*>(&bookTemp),sizeof(Libro));
			if(!Registry.eof()){
				if(!bookTemp.getDeleted()){
					keys.push_back(new char[14]);
					char finalKey[14] ;
					for (int i = 0; i < 13; ++i){
						finalKey[i] = bookTemp.getISBN()[i+9];
					}
					finalKey[14] = '\0';
					strcpy(keys.at(keys.size()-1),finalKey);
					offsets.push_back(contadorRegistros*sizeof(Libro) + sizeof(header));
					contadorRegistros++;

					}else{
						contadorRegistros++;
					}
				}
					
		}
	

		vector<indexFile*> newRegistros;

		for (int i = 0; i < keys.size(); ++i){
			newRegistros.push_back(new indexFile(keys.at(i),offsets.at(i)));
		}

		//ORDENANDO LA LISTA DE newRegistros
		long int key1;
		long int key2;
		char keyTemp[14];
		long int offsetTemp;
		bool isI;
		bool isJ;
		indexFile indexTemp;
		vector<int> erasedPos;
		if(newRegistros.size()>1){
			for (int i = 0; i < newRegistros.size()-1; ++i){
				for (int j = 1; j < newRegistros.size(); ++j){
						
					key1 = atol(newRegistros.at(i)->getLlave());
					key2 = atol(newRegistros.at(j)->getLlave());

					if(key2<key1){
						//indexTemp = *newRegistros.at(i);
						//newRegistros.at(i) = newRegistros.at(j);
						//&newRegistros.at(j) = indexTemp;
						strcpy(keyTemp,newRegistros.at(i)->getLlave());
						//cout<<"Este es el KeyTemp: "<<keyTemp<<endl;
						offsetTemp = newRegistros.at(i)->getOffset();
						//cout<<"Este es su offset: "<<offsetTemp<<endl;
						delete newRegistros.at(i);
						newRegistros.at(i) = new indexFile(newRegistros.at(j)->getLlave(),newRegistros.at(j)->getOffset());
						delete newRegistros.at(j);
						newRegistros.at(j) = new indexFile(keyTemp,offsetTemp);






						/*
						isI = false;
						isJ = false;
						for (int k = 0; k < erasedPos.size(); ++k){
							if(i == erasedPos.at(k)){
								isI = true;
								break;
							}
						}
						for (int k = 0; k < erasedPos.size(); ++k){
							if(j == erasedPos.at(k)){
								isJ = true;
								break;
							}
						}

						if(!isI){
							erasedPos.push_back(i);
						}
						if(!isJ){
							erasedPos.push_back(j);
						}
						*/
					}
				}	
			}
		}


		ofstream indice("index.bin",ios::binary| ios::trunc | ios::out);
		for (int i = 0; i < newRegistros.size(); ++i){
			indice.write(reinterpret_cast<char*>(newRegistros.at(i)),sizeof(indexFile));
		}
		indice.close();

		for (int i = 0; i < keys.size(); ++i){
			delete keys.at(i);
		}
		//bool deleteR;
		//for (int i = 0; i < newRegistros.size(); ++i){
			/*deleteR = true;
			for (int j = 0; j < erasedPos.size(); ++j){
				if(i == erasedPos.at(j)){
					deleteR = false;
					break;
				}
			}
			if(deleteR){
				delete newRegistros.at(i);
			}
			*/
		//	delete newRegistros.at(i);
		//}
			for (int i = 0; i < newRegistros.size(); ++i){
				delete newRegistros.at(i);
			}




	}

	bool RealDirty = false;
	int contadorAle = 0;

	do {

		ifstream ifstreamer("libros.bin", ios::binary | ios::in);
		Header temptemptemp;
		ifstreamer.seekg(0);
		ifstreamer.read(reinterpret_cast<char*>(&temptemptemp), sizeof(Header));
		ifstreamer.close();
		cout<<"Avail List = "<<temptemptemp.getAvailList()<<endl;

		seleccionMenu = menu();
		cout<<seleccionMenu<<endl;
		ifstream infile("libros.bin",ios::binary);
		if (!headerExists){
			if(!infile.good()){
				infile.close();
				ofstream fileWrite("libros.bin",ios::binary| ios::trunc | ios::out);
				//int availList,int sizeOfCampo,int RecordCount,bool DirtyBit
				//fileWrite.write(reinterpret_cast<char*>(&header,sizeof(Header)));
				fileWrite.write(reinterpret_cast<char*>(&header),sizeof(Header));
				fileWrite.close();
				headerExists = true;
				
			}else{
				ifstream infile("libros.bin",ios::binary);			
				infile.read(reinterpret_cast<char*>(&header),sizeof(Header));
				infile.close();
				headerExists = true;
			}
		}

		if(seleccionMenu==1){
			contadorAle++;
			char defaultAvail[] = "0000000-1";
			char ISBN [23];
			char ISBNTemp[14];
			char Nombre[76];
			char Autor[76];
			unsigned int editorialID;
			cin.ignore();
			cout<<"Porfavor ingrese el ISBN del libro: ";
			cin.getline(ISBNTemp,14);
			strcpy(ISBN,defaultAvail);
			strcat(ISBN,ISBNTemp);
			cout<<endl;
			cout<<"Porfavor ingrese el nombre del libro: ";
			cin.getline(Nombre,76);
			cout<<endl;
			cout<<"Porfavor ingrese el nombre del autor del libro: ";
			cin.getline(Autor,76);
			cout<<endl;
			cout<<"porfavor ingrese un ID (1 - 20) : ";
			cin>>editorialID;
			Libro libroTemp(ISBN,Nombre,Autor,editorialID);
			Header Heather;

			ifstream heath("libros.bin", ios::binary | ios::in);
			heath.seekg(0);
			heath.read(reinterpret_cast<char*>(&Heather), sizeof(Header));
			heath.close();




			if (Heather.getAvailList()==-1){
				ofstream outfile("libros.bin",ios::binary | ios::app | ios::ate);
				outfile.write(reinterpret_cast<char*>(&libroTemp),sizeof(Libro));
				outfile.close();
				header.setRecordCount(header.getRecordCount()+1);
				headerDirty = true;
				RealDirty = true;

			}else{
				long int offset = Heather.getAvailList();
				long int nextOffset;
				ifstream readFile("libros.bin", ios::binary | ios::in);
				Libro Book;
				readFile.seekg(offset);
				readFile.read(reinterpret_cast<char*>(&Book), sizeof(Libro));
				readFile.close();
				nextOffset = Book.getAvail();


				fstream outfile("libros.bin", ios::binary | ios::in | ios::out);
				outfile.seekp(offset);
				outfile.write(reinterpret_cast<char*>(&libroTemp), sizeof(Libro));

				Heather.setAvailList(nextOffset);
				outfile.seekp(0);
				outfile.write(reinterpret_cast<char*>(&Heather), sizeof(Header));
				outfile.close();


				header.setRecordCount(header.getRecordCount()+1);
				headerDirty = true;
				RealDirty = true;






				/*
				long int offset = (header.getAvailList()*sizeof(Libro)) + sizeof(Header);
				streampos pos = offset;
				ifstream infile("libros.bin", ios::binary);
				infile.seekg(pos);
				Libro temp;
				infile.read(reinterpret_cast<char*>(&temp),sizeof(Libro));
				char deletedISBN[23];
				strcpy(deletedISBN,temp.getISBN());
				char newposition[7];

				int contador = 0;
				int contadorAsterisco = 0;
				int debug;
				while(contadorAsterisco<2){
					if(deletedISBN[contador]=='*'){
						contadorAsterisco++;
					}else{
						if(contador==1){
							newposition[0] = deletedISBN[contador+1];
						}else{
							newposition[contador+1] = deletedISBN[contador];
						}
					}
				}
				//long int nuevoElementoAvail = static_cast<long int>(&newposition);
				long int nuevoElementoAvail = (long int) newposition;
				header.setAvailList(nuevoElementoAvail);

				fstream outfile("libros.bin", ios::binary | ios::out | ios::in);
				outfile.seekp(pos);
				outfile.write(reinterpret_cast<char*>(&libroTemp), sizeof(Libro));
				outfile.close();
				headerDirty = true;
				header.setRecordCount(header.getRecordCount()+1);
				RealDirty = true;
				*/

				
			}

				
		
		}else if(seleccionMenu==2){
			ifstream infile("libros.bin",ios::binary);
			Libro libro;
			infile.seekg(sizeof(Header));
			int contador = 0;
			while(!infile.eof()){
				char actualISBN[23];
				char ISBNfinal[14];
				int contadorFinal=0;
				int contadorAsterisco=0;
				

				infile.read(reinterpret_cast<char*>(&libro),sizeof(Libro));	
				strcpy(actualISBN,libro.getISBN());

				/*if (actualISBN[0] == '*'){
					for (int i = 0; i < strlen(actualISBN); ++i){
						if(actualISBN[i] == '*'){
							contadorAsterisco++;
						}
						if(contadorAsterisco == 2){
							ISBNfinal[contadorFinal] = actualISBN[i];
							contadorFinal++;
						}
					}
				}
				*/
				char ISBNToShow[14];
				int contadorToShow=0;
				if(ISBNfinal[7] == '-'){
					for (int i = 0; i < 14; ++i){
						ISBNToShow[i] = libro.getISBN()[i+9];
					}
					ISBNToShow[14] = '\0';
					
					
					if (!infile.eof() && libro.getMark() != '*'){
						contador++;
						cout<<endl;
						cout<<contador<<": ";
						cout<< "ISBN: "<<ISBNToShow<<endl;
						cout<<"Nombre del Libro: "<<libro.getNombre()<<endl;
						cout<<"Autor: "<<libro.getAutor()<<endl;
						cout<<"Nombre de la Editorial: "<<nombreEditoriales[libro.getEditorialID()]<<endl;
						cout<<"Direccion de la Editorial: "<<direccionEditoriales[libro.getEditorialID()]<<endl<<endl;

					}

				}else{
					char ISBNToShow[14];
					int contadorshow = 0;
					/*
					for (int i = 0; i < strlen(libro.getISBN()); ++i){
						if (i>8){
							ISBNToShow[contadorshow] = libro.getISBN()[i];
							contadorshow++;
						}
					}
					*/
					for (int i = 0; i < 14; ++i){
						ISBNToShow[i] = libro.getISBN()[i+9];
					}
					ISBNToShow[14] = '\0';
					if (!infile.eof() && libro.getMark() != '*'){
						contador++;
						cout<<contador<<"= ";
						cout<< "ISBN: "<<ISBNToShow<<endl;
						cout<<"Nombre del Libro: "<<libro.getNombre()<<endl;
						cout<<"Autor: "<<libro.getAutor()<<endl;
						cout<<"Nombre de la Editorial: "<<nombreEditoriales[libro.getEditorialID()]<<endl;
						cout<<"Direccion de la Editorial: "<<direccionEditoriales[libro.getEditorialID()]<<endl<<endl;
					}

				}

					
			}
			infile.close();
			
			

		}/*else if (seleccionMenu==3){

			//Modificar
			char busquedaLibro[14];
			cout<<endl<<"Porfavor ingrese el ISBN del libro que desea modificar: ";
			cin.ignore();
			cin.getline(busquedaLibro,14);
			cout<<endl;
			ifstream index("index.bin",ios::binary|ios::in);
			indexFile indexTemp;
			long int offset;
			bool found = false;
			while(!index.eof()){
				index.read(reinterpret_cast<char*>(&indexTemp),sizeof(indexFile));
				if(!index.eof()){
					if(strcmp(busquedaLibro,indexTemp.getLlave()) == 0){
						cout<<"Se encontro el Libro: "<<endl;
						offset = indexTemp.getOffset();
						found = true;
						break;
					}
				}
			}
			index.close();

			if(found){
				Libro actual;
				ifstream libroFile("libros.bin", ios::binary | ios::in);
				libroFile.seekg(offset);
				libroFile.read(reinterpret_cast<char*>(&actual), sizeof(Libro));
				char toShow[14];
				int eleccionMod;
				for (int i = 0; i < 14; ++i){
					toShow[i] = actual.getISBN()[i+9];
				}
				toShow[14] = '\0';

				cout<< "ISBN: "<<toShow<<endl;
				cout<<"Nombre del Libro: "<<actual.getNombre()<<endl;
				cout<<"Autor: "<<actual.getAutor()<<endl;
				cout<<"ID Editorial: "<<actual.getEditorialID()<<endl<<endl;

				cout<<"Desea cambiar el ISBN junto a los otros datos? "<<endl;
				cout<<"1) Si"<<endl;
				cout<<"2) No"<<endl;
				cin>>eleccionMod;
				if(eleccionMod == 1){
					char ISBNTemp[14];
					char TempNombre[76];
					char TempAutor[76];
					unsigned int TempEditorial;
					cin.ignore();
					cout<<"Porfavor ingrese el ISBN del libro: ";
					cin.getline(ISBNTemp,14);
					char temptemp[23];
					strcpy(temptemp, actual.getISBN());
					for (int i = 0; i < 14; ++i){
						temptemp[i+9] = ISBNTemp[i];
					}
					actual.setISBN(temptemp);
					cout<<endl;
					cout<<"Porfavor ingrese el nombre del libro: ";
					cin.getline(TempNombre,76);
					cout<<endl;
					cout<<"Porfavor ingrese el nombre del autor del libro: ";
					cin.getline(TempAutor,76);
					cout<<endl;
					cout<<"porfavor ingrese un ID: ";
					cin>>TempEditorial;
					actual.setNombre(TempNombre);
					actual.setAutor(TempAutor);
					actual.setEditorialID(TempEditorial);

					fstream bookMod("libros.bin", ios::binary | ios::in | ios::out);
					bookMod.seekp(offset);
					bookMod.write(reinterpret_cast<char*>(&actual), sizeof(Libro));
					bookMod.close();
					headerDirty = true;
				}else{
					char TempNombre[76];
					char TempAutor[76];
					unsigned int TempEditorial;
					cin.ignore();
					cout<<endl;
					cout<<"Porfavor ingrese el nombre del libro: ";
					cin.getline(TempNombre,76);
					cout<<endl;
					cout<<"Porfavor ingrese el nombre del autor del libro: ";
					cin.getline(TempAutor,76);
					cout<<endl;
					cout<<"porfavor ingrese un ID: ";
					cin>>TempEditorial;
					actual.setNombre(TempNombre);
					actual.setAutor(TempAutor);
					actual.setEditorialID(TempEditorial);
					cout<<"temp editorial: "<<actual.getEditorialID()<<endl;

					fstream bookMod("libros.bin", ios::binary | ios::in | ios::out);
					bookMod.seekp(offset);
					bookMod.write(reinterpret_cast<char*>(&actual), sizeof(Libro));
					bookMod.close();
				}
			}else{
				cout<<"Lo siento no pude encontrar ese libro :( "<<endl;
			}

		}*/else if (seleccionMenu==3){
			crearIndice();
			

			char busquedaLibro[14];
			cout<<endl<<"Porfavor ingrese el ISBN del libro que desea eliminar: ";
			cin.ignore();
			cin.getline(busquedaLibro,14);
			long int offset;
			bool found = false;
			cout<<endl;
			indexFile indexTemp1;
			ifstream indexito("index.bin", ios::binary | ios::in);
			
		
			while(!indexito.eof()){
				indexito.read(reinterpret_cast<char*>(&indexTemp1),sizeof(indexFile));
				if(!indexito.eof()){
					if(strcmp(busquedaLibro,indexTemp1.getLlave()) == 0){
						cout<<"Se encontro el Libro: "<<endl;
						offset = indexTemp1.getOffset();
						found = true;
						break;
					}
				}
			}
			indexito.close();
			if (found){
				int erase;
				Libro actual;
				ifstream libroFile("libros.bin", ios::binary | ios::in);
				libroFile.seekg(offset);
				libroFile.read(reinterpret_cast<char*>(&actual), sizeof(Libro));
				libroFile.close();
				char toShow[14];
				int eleccionMod;
				for (int i = 0; i < 14; ++i){
					toShow[i] = actual.getISBN()[i+9];
				}
				toShow[14] = '\0';

				cout<< "ISBN: "<<toShow<<endl;
				cout<<"Nombre del Libro: "<<actual.getNombre()<<endl;
				cout<<"Autor: "<<actual.getAutor()<<endl;
				cout<<"ID Editorial: "<<actual.getEditorialID()<<endl<<endl;

				cout<<endl<<"De verdad quiere borrar este libro?"<<endl;
				cout<<"1) SI"<<endl;
				cout<<"2) NO"<<endl;
				cin >> erase;
				cin.ignore();

				if(erase == 1){
					

					Header headercito;
					ifstream MaxHeader("libros.bin" , ios::binary | ios::in);
					MaxHeader.read(reinterpret_cast<char*>(&headercito), sizeof(Header));
					if (headercito.getAvailList() == -1){

						headercito.setAvailList(offset);
						actual.setAvail(-1);
					}else{
						actual.setAvail(headercito.getAvailList());
						headercito.setAvailList(offset);
					}
					MaxHeader.close();

					fstream borrar("libros.bin", ios::binary| ios::in | ios::out);
					borrar.seekg(0);
					borrar.write(reinterpret_cast<char*>(&headercito), sizeof(Header));
					borrar.seekg(offset);
					actual.setDeleted(true);
					actual.setMark('*');
					borrar.write(reinterpret_cast<char*>(&actual), sizeof(Libro));
					borrar.flush();
					borrar.close();
					headerDirty = true;
				}


			}
			noWrite = true;

	

		}else if (seleccionMenu == 4){
Exemplo n.º 7
0
int Servicios::quitarArchivo(string unId)
{
	unsigned int id = atoi(unId.c_str());
	unsigned int offset = 0;

	cout<<"Eliminando libro "<<id<<"..."<<endl;

	//recuperar el offset del primario

	string pathArbolPrimario = Parametros().getParametro(CARPETA_DATOS);
	pathArbolPrimario += NOMBRE_BMAS_PRIMARIO;

	if (pathArbolPrimario == "") return ERROR_RUTA_BMAS_PRIMARIO;

	ArbolBMasNumerico *arbolP = new ArbolBMasNumerico(pathArbolPrimario, TAMANIO_BLOQUE_BMAS_NUMERICO);

	resultadoOperacion resultado(OK);

	Registro* registro = arbolP->buscarRegistroNumerico(id, &resultado);

	//TODO ver si esta recuperando bien el offset
	if (registro && resultado.getDescripcion() == "ENCONTRADO")
		offset = registro->getReferencias()->front();
	else
		return ERROR_LIBRO_INEXISTENTE;


//quitar de el archivo de registros variables

	string arcLibros = Parametros().getParametro(ARCHIVO_LIBROS);
	ArchivoLibros *archivo = new ArchivoLibros(arcLibros);
	Libro *libro = archivo->recuperarLibro(offset);
//	cout <<"Autor: "<< libro->getAutor() <<endl;
//	cout <<"Editorial: "<< libro->getEditorial() <<endl;
//	cout <<"Titulo: "<< libro->getTitulo() <<endl;
//	cout <<"Id: "<< libro->getId() <<endl;
//	cout <<"Cant.palabras: " << libro->getCantPalabras() << endl;
//	cout << "Presione ENTER para continuar...." << endl;
//	cin.get();

//	cout << "SACO EL LIBRO DEL ARCHIVO DE REGISTROS VARIABLES" << endl;
	archivo->suprimirLibro(offset);


//quitar del primario

	//cout << "QUITO DEL PRIMARIO EL ID" << endl;

	arbolP->eliminarNumerico(libro->getId());

	delete arbolP;

//quitar de los indices

	//cout << "SACO DE LOS INDICES" << endl;

	//cout << "SACO DE AUTORES" << endl;
	sacarDelArbol(NOMBRE_BMAS_AUTORES,libro->getAutor(),libro->getId());
	//cout << "Presione ENTER para continuar...." << endl;
	//cin.get();

	//cout << "SACO DE EDITORIALES" << endl;
	sacarDelArbol(NOMBRE_BMAS_EDITORIALES,libro->getEditorial(),libro->getId());
	///cout << "Presione ENTER para continuar...." << endl;
	//cin.get();

	//cout << "SACO DE TITULOS" << endl;
	sacarDelHash(NOMBRE_HASH_TITULOS,libro->getTitulo(),libro->getId());
	//cout << "Presione ENTER para continuar...." << endl;
	//cin.get();

	//cout << "SACO PALABRAS" << endl;
	//cout << "Procesando la quita del indice..." << endl;
	set<string> *palabras = libro->getListaPalabras();

	for (set<string>::iterator it = palabras->begin(); it != palabras->end(); it++)
	{
		sacarDelHash(NOMBRE_HASH_PALABRAS, *it ,libro->getId());
	}


//quitar de la lista de libros sin procesar
	//cout << "SACO DE LOS INDICES SIN PROCESAR" <<endl;
	SinIndice *listas  = SinIndice().getInstancia();
	listas->sacarLibroDeTodasLasListas(id);

	delete archivo;

	/*******************AGREGADO ENTREGA II*************************/


	string pathArbolPalabras = Parametros().getParametro(CARPETA_DATOS);
	pathArbolPalabras += NOMBRE_BMAS_PALABRAS;
	pathArbolPalabras += "_" + Util().UIntToString(id);

	resultadoOperacion resultadoOp(OK);


	ArbolBMasAlfabetico *arbolPal = new ArbolBMasAlfabetico(pathArbolPalabras, TAMANIO_BLOQUE_BMAS_PALABRAS);



	//recorrer el arbol de palabras
	Registro *reg = arbolPal->buscarRegistro("a",&resultadoOp);
	unsigned int lista;

	while (reg != NULL)
	{
		lista = reg->getReferenciai(1);
		ListasIds().eliminarLista(lista);
		reg = arbolPal->siguiente();
	}

	arbolPal->~ArbolBMasAlfabetico();

	Util().eliminarArchivo(pathArbolPalabras);

	/*******************AGREGADO ENTREGA II*************************/


	return 0;


}
Exemplo n.º 8
0
int Servicios::obtenerLibro(string unId)
{
	unsigned int id = atoi(unId.c_str());
	fstream libro;
	string rutaSalida = Parametros().getParametro(CARPETA_SALIDA);
	string arcLibros = Parametros().getParametro(ARCHIVO_LIBROS);

	if (arcLibros == "") return ERROR_RUTA_ARCHIVO_LIBROS;

 	ArchivoLibros *archivo = new ArchivoLibros(arcLibros);
	Libro *unLibro = NULL;
	//intento recuperar el libro
	int resultadoRecuperacion = 0;
	resultadoRecuperacion = recuperarLibro(id,&unLibro);
	if( resultadoRecuperacion == ERROR_LIBRO_INEXISTENTE){
		return resultadoRecuperacion;
	};
// BORRAR
//	Parser *unParser = new Parser();
//	unParser->parsear("./archivos/libros/Justin Somper - Vampiratas 3 - Emboscada en el Océano.txt");
//	Libro *unLibro = unParser->getLibro();
//BORRAR

	string nombreArchivo = rutaSalida + unLibro->getTitulo();
	nombreArchivo += ".txt";

	libro.open(nombreArchivo.c_str(), ios::binary | ios::out);

	unsigned int tamanio;
	char* buff;
	string linea;

//autor
	linea = "Autor: ";
	linea += unLibro->getAutor();
	linea += "\n";
//editorial
	linea += "Editorial: ";
	linea += unLibro->getEditorial();
	linea += "\n";
//titulo
	linea += "Titulo: ";
	linea += unLibro->getTitulo();
	linea += "\n";
//texto
	linea += "\n\n...\n";
	linea += unLibro->getTexto();
	linea += "\n";

	tamanio = linea.size();
	buff= new char[tamanio];
	memcpy(buff,linea.c_str(),tamanio);
	libro.write(buff,tamanio);
	delete [] buff;

	libro.close();

	archivo->~ArchivoLibros();
	unLibro->~Libro();

	return 0;
}
Exemplo n.º 9
0
int Servicios::tomarTexto(string ruta)
{

//parsear el libro
	Parser *unParser = new Parser();
	cout << "Procesando Libro...." << endl;
	if (unParser->parsear(ruta) != EXITOSO)
	{
		string rutaLibros = Parametros().getParametro(CARPETA_LIBROS);
		ruta = rutaLibros + ruta;
		if (unParser->parsear(ruta) != EXITOSO) return ERROR_RUTA_INVALIDA;
	}

	Libro *unLibro = unParser->getLibro();

	//cout << unLibro->toString() << endl; //BORRAR SOLO PARA PROBAR LA IMPRESION



	//cout << "parsie el libro" << endl;


//meter el libro en el archivo de registros variables
	string rutaArcLibros = Parametros().getParametro(ARCHIVO_LIBROS);

	if (rutaArcLibros == "") return ERROR_RUTA_ARCHIVO_LIBROS;

	ArchivoLibros *archivo = new ArchivoLibros(rutaArcLibros);

	//cout << "creo archivo de libros" << endl;



	unsigned int offset = 0;
	offset = archivo->agregarLibro(unLibro);
	delete archivo;

	//cout << "agrego el libro" << endl;



	string pathArbolPrimario = Parametros().getParametro(CARPETA_DATOS);
	pathArbolPrimario += NOMBRE_BMAS_PRIMARIO;

	if (pathArbolPrimario == "") return ERROR_RUTA_BMAS_PRIMARIO;

	ArbolBMasNumerico *arbolP = new ArbolBMasNumerico(pathArbolPrimario, TAMANIO_BLOQUE_BMAS_NUMERICO);
	//cout << "id: "<< unLibro->getId() << endl;
	arbolP->insertarNumerico(unLibro->getId(),offset);

	delete arbolP;

	//cout << "agrego al indice primario" << endl;


	/*******************AGREGADO ENTREGA II*************************/

	//crear el arbol de parlabras
	string pathArbolPalabras = Parametros().getParametro(CARPETA_DATOS);
	pathArbolPalabras += NOMBRE_BMAS_PALABRAS;
	pathArbolPalabras += "_" + Util().UIntToString(unLibro->getId());

	ArbolBMasAlfabetico *arbolPal = new ArbolBMasAlfabetico(pathArbolPalabras, TAMANIO_BLOQUE_BMAS_PALABRAS);

	map<string, list<int> > mapa = unParser->obtenerPalabras2();
	map<string, list<int> >::iterator itMap;
	string clave;
	unsigned int idLista;
	unsigned int posPal;
	string mejorP;
	unsigned int vieja,nueva,mejor = 0;

	//cout << "llego a insertar las cosas al arbol" << endl;
	//cin.get();

	///////////////////////  agrego la funcionalidad para guardar normas infinito   ///////

	string pathArbolPrim = Parametros().getParametro(CARPETA_DATOS);
	pathArbolPrim+= NOMBRE_BMAS_PRIMARIO;
	ArbolBMasNumerico* arbolPrimario = new ArbolBMasNumerico(pathArbolPrim,
			TAMANIO_BLOQUE_BMAS_NUMERICO);

	resultadoOperacion result(OK);
	Registro* regActual = arbolPrimario->buscarRegistroNumerico(0, &result);
	unsigned int N = 1;
	while (regActual != NULL) {
		regActual = arbolPrimario->siguiente();
		N++;
	}


	delete arbolPrimario;


	double acumuladoNormaInf=0;

	for (itMap = mapa.begin(); itMap != mapa.end(); itMap++)
	{
		clave  = itMap->first;
		posPal = itMap->second.front();
		nueva = itMap->second.size();

		list<unsigned int> listaIds;

		double aij = itMap->second.size();
		string rutahash= Parametros().getParametro(CARPETA_DATOS);
		rutahash+=NOMBRE_HASH_PALABRAS;
		Hash hash(rutahash);
		Registro* registro= hash.buscar(itMap->first);

		double ni= 1;


		if (registro!= NULL){

			offset= registro->getAtributosEnteros()->front();
			ListasIds().obtenerListaIds(offset, &listaIds);
			ni= listaIds.size();

		}

		double pesoGlobal= log10((double)N/(double)ni);
		double peso= aij*pesoGlobal;
		acumuladoNormaInf+= pow(peso,2);

		ListasIds().agregarPosPalabra(&idLista,posPal,true);
		arbolPal->insertar(clave,idLista);

		list<int>::iterator itPos = itMap->second.begin();
		itPos++; //para salir del front por que ya se cargo antes
		for ( ; itPos != itMap->second.end() ; itPos++)

		{
			posPal = *itPos;
			ListasIds().agregarPosPalabra(&idLista,posPal,false);

		}

		delete registro;
	}
	double normaInfinito= sqrt(acumuladoNormaInf);
	//cout<<normaInfinito<<endl;
	archivoNormasInf archivoNormas;
	archivoNormas.escribirNorma(normaInfinito);

	delete arbolPal;
/**********************************************borrar***************************************************/
//	list<unsigned int> *lista = new list<unsigned int>();
//	ListasIds().obtenerListaIds(1,lista);
//
//	for (list<unsigned int>::iterator it = lista->begin(); it != lista->end() ; it ++)
//		cout << *it << endl;





	/*******************AGREGADO ENTREGA II*************************/


	delete unParser;


	//agregar el libro a las listas
	SinIndice *listas = SinIndice().getInstancia();

	//ProcesadorConsultas().actualizarPesos();

	unsigned int id = unLibro->getId();

	delete unLibro;

	return listas->agregarLibroPendienteATodasLasListas(id);

	//cout << "agrego a las listas no procesadas" << endl;

}