C++ Registro类代码示例

void Servidor::modificarRegistro() {
	Protocolo protocolo;
	string resp;

	/* Insertar en la base de datos */
	Registro existReg(peticionRecibida.nombreCons, (char*) "", (char*) "");
	Registro nuevoReg;
	nuevoReg.crearDesdeMensaje(peticionRecibida);
	int result = this->bd.modificar(existReg, nuevoReg);

	/* Generar mensaje de respuesta */
	if (result == SUCCESS){
		resp = "El registro ha sido modificado con éxito con la siguiente información nueva.";
		resp += (!nuevoReg.getNombre().empty()) ? "\nNombre: de " + existReg.getNombre() + " a " + nuevoReg.getNombre() : "";
		resp += (!nuevoReg.getDireccion().empty()) ? "\nDirección: de " + existReg.getDireccion() + " a " +  nuevoReg.getDireccion() : "";
		resp += (!nuevoReg.getTelefono().empty()) ? "\nTeléfono: de " + existReg.getTelefono()  + " a " +  nuevoReg.getTelefono() : "";
		resp += "\n";
	} else if (result == ERR_NO_EXISTE){
		resp = "El registro a modificar no existe. ";
	} else if (result == ERR_DUPLICADO){
		resp = "El registro no se ha modificado con éxito pues está en conflicto con otro existente.";
	}

	/* Generar respuesta */
	mensaje respuesta;
	respuesta.ttl = 1;
	respuesta.mtype = RESPUESTA;
	respuesta.pid = getpid();
	strcpy(respuesta.textoRespuesta, resp.c_str());
	this->respuestas.push_back(respuesta);
}

void Servidor::insertarRegistro() {
	Protocolo protocolo;
	string resp;
	/* Insertar en la base de datos */
	Registro reg;
	reg.crearDesdeMensaje(peticionRecibida);
	int result = this->bd.insertar(reg);
	if (result == SUCCESS){
		resp = "El registro ha sido insertado con éxito con la siguiente información.";
		resp += "\nNombre: " + reg.getNombre();
		resp += "\nDirección: " + reg.getDireccion();
		resp += "\nTeléfono: " + reg.getTelefono();
		resp += "\n";
	} else if (result == ERR_DUPLICADO){
		resp = "El registro no se ha insertado con éxito pues está duplicado";
	} else if (result == ERR_CAMPO_REQUERIDO){
		resp = "El registro no se ha insertado con éxito pues faltan datos requeridos.";
	}

	/* Generar respuesta */
	mensaje respuesta;
	respuesta.ttl = 1;
	respuesta.mtype = RESPUESTA;
	respuesta.pid = getpid();
	strcpy(respuesta.textoRespuesta, resp.c_str());
	this->respuestas.push_back(respuesta);
}

void TestParserDeLibros::testObtenerPalabrasConTodosLosDatos(){
	string strLibro = generarMockLibroCompleto();
	const char *auxlibro= strLibro.c_str();
	char* libro;
	libro = const_cast<char*>(auxlibro);
	Registro* regLibro = this->parser->obtenerRegistroDeLibro((libro) );

	list<string> palabrasPatron;
	generarListaPatron(palabrasPatron);
	list<string> palabras = regLibro->getPalabras();
	bool diferencia = false;

	list<string>::iterator it1 = palabrasPatron.begin();
	list<string>::iterator it2 = palabras.begin();
	string palabra, palabraPatron;
	while (( it1 != palabrasPatron.end()) && !(diferencia)){
		while (it2 != palabras.end()){
			palabraPatron = (*it1);
			palabra = (*it2);
			it1++; it2++;
			if (palabra.compare(palabraPatron)){
				diferencia = true;
			}
		}
	}
	CPPUNIT_ASSERT_MESSAGE("La lista de palabras no es correcta", diferencia == false );
}

int Servicios::recuperarLibro(unsigned int idLibro, Libro **libro)
{
	unsigned int offset = 0;

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

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

	resultadoOperacion resultado(OK) ;

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

	if (registro && resultado.getDescripcion() == "ENCONTRADO"){
		offset = registro->getReferencias()->front();
	}
	else{
		return ERROR_LIBRO_INEXISTENTE;
	}


	string rutaArcLibros = Parametros().getParametro(ARCHIVO_LIBROS);

	if (rutaArcLibros == "") return ERROR_RUTA_ARCHIVO_LIBROS;

	ArchivoLibros *archivo = new ArchivoLibros(rutaArcLibros);

	*libro = (archivo->recuperarLibro(offset));

	delete archivo;

	delete arbolP;

	return 0;
}

Registro* ArbolBMasNumerico::crearRegistroClave(string clave) {
	stringstream buffer(stringstream::in | stringstream::out);

	buffer << clave;
	unsigned int claveNumerica;
	buffer >> claveNumerica;
	Registro* unRegistro = new Registro();
	unRegistro->agregarAtribEntero(claveNumerica);
	return unRegistro;
}

void TestParserDeLibros::testObtenerEditorialEnLibroSinEditorial(){
	string strLibro = generarMockLibroSinEditorial();
	const char *auxlibro= strLibro.c_str();
	char* libro;
	libro = const_cast<char*>(auxlibro);
	Registro* regLibro = this->parser->obtenerRegistroDeLibro((libro) );

	string editorial = regLibro->getEditorial();
	CPPUNIT_ASSERT_MESSAGE( "No se creó la editorial por defecto en el registro",!(editorial.empty() ) );
}

int main()
{
    // Prevent zombie processes
    struct sigaction sigchld_action;
    sigchld_action.sa_handler = SIG_DFL;
    sigchld_action.sa_flags = SA_NOCLDWAIT;
    sigaction(SIGCHLD, &sigchld_action, NULL);
    Registro a;
    a.init();
    return 0;
}

// Asignado a Richard
Registro Data::selectRecord(unsigned int index)
{
    InfoReg reg;
    fstream disco;
    disco.open(path, ios::binary | ios::in | ios::out);

    if (!disco) {
        throw SMException("No se pudo abrir el archivo tablespace.dat");
    }

    unsigned int offset = ( 4096 * header.blockID ) + sizeof(Header) + sizeof(InfoD);
    int x=0;
    int cant = getCantRegFisicos();


    if(index>=getCantRegActivos())
    {
        throw SMException("Index invalido para el bloque de Data " + header.blockID);
    }
    else
    {

    for(int i=0; i< cant; i++)
    {
        disco.seekg(offset);
        disco.read( (char*) &reg , sizeof(InfoReg));

        if(reg.tombstone) // == true
        {
            continue;
        }
        else if(!reg.tombstone)// == false
        {
            if(x==(int)index)
            {
                unsigned char *contenido = (unsigned char *)malloc(reg.tam);
                disco.read((char*)contenido,reg.tam);
                Registro registro;
                registro.info = reg;
                registro.setContentReg(contenido);
                return registro;
            }
            else
            {
                x++;
            }
        }
        offset+=sizeof(InfoReg) + reg.tam;
    }
    }


}

Registro Registro::CopiarCampos(const Conj<String> cc, const Registro r2) const{
	Conj<String>::const_Iterador it = cc.CrearIt();
	Registro res(*this);
	while(it.HaySiguiente()){
		if (Def(it.Siguiente())){
			res.DefinirLento(it.Siguiente(), r2.Obtener(it.Siguiente()));
		}else{
			res.Definir(it.Siguiente(), r2.Obtener(it.Siguiente()));
		}
		it.Avanzar();
	}
	return res;
}

bool InterfazCliente::add(vector<string> vec){
	bool valid,nombre,dir,tel;
	Registro rec = getRecord(vec,valid,nombre,dir,tel);
	if(valid&&(nombre&&dir&&tel)){
		bool resultado = comunicador.enviarAlta(rec);
		if (resultado) {
			cout<<RESULT_ADD_MESSAGE<<rec.toString()<<endl;
		} else {
			cout<<RESULT_ADD_MESSAGE_FAIL<<rec.toString()<<endl;
		}
	}else{
		cout<<INVALID_ADD_MESSAGE<<endl;
	}
	return true;
}

static void f(Hash* hash,unsigned int cant){
	Registro* reg;
	for (unsigned int i=0;i<cant;i++){
		stringstream a;
		unsigned int b= i;
		a<<b;
		string str;
		a>>str;
		reg=new Registro(str);
		reg->agregarAtribEntero(i);
		hash->insertar(reg);
		delete reg;

	}
}

response Servidor::armarResponse(Registro &reg,long pid)
{
	response resp;
	resp.reg = reg.getRegistro();
	resp.mtype = pid;
	return resp;
}

Registro* ArbolBiselado::obtenerMayorDeLosMenores(Nodo* nodo){

	Nodo* nodoActual = nodo;
	while(true)
    {
        try
        {
            nodoActual = nodoActual->getHijoDerecho();
        }
		catch(NumeroDeBloqueInvalido e)
		{
		    break;
		}
		nodosARotar->apilar(nodoActual);
		movimientos->apilar('d');

	}
	//En caso de que el nodo hoja que contenia el registro sustituto
	//haya quedado vacio, lo desapilo para el biselado y elimino la duplicacion
	desapilarSiNodoQuedaVacio(nodoActual);

	//obtengo el registro original a eliminar
	Registro* original = nodoActual->getListaDeRegistros()->obtenerUltimo();

	//duplico su informacion en el que se insertara en el nodo que quedo vacio
	Registro* duplicado = new Registro(original->getID(),original->getCodigo(), original->getDescripcion());

	//elimino el original si no es el unico registro restante o es hoja
	if(nodoActual->getListaDeRegistros()->getTamanio() > 1 || nodoActual->esHoja()){

		 nodoActual->eliminarRegistro(original);

	} else //en caso de que no (esta es la recursion) y el nodo prestador a su vez
		//queda vacio le aplico recursion para que busque otra vez el menor de los mayores
		//o mayor de los menores y repita todo el proceso, mejor dicho.
	{
		//fijate que en el unico caso que hay que hacer recursion
		//es si caemos en un nodo interno con un solo registro
		// (A || B) == ¬A && ¬B.
		eliminarEnNodoInterno(original,nodoActual);
	}

	return duplicado;

}

void TestArchivoDeBuckets::mostrarBucket(ArchivoDeBuckets* archivo,int numeroDeBucket) {
    Bucket* bucketNuevo = archivo->obtenerBucket(numeroDeBucket);

    string* serializacion = bucketNuevo->serializar();
    cout << "bucketSerializado "<< serializacion->size() << endl;
    delete serializacion;

    int cantRegistros = bucketNuevo->getCantidadDeRegistros();

    list<Registro*>::iterator it = bucketNuevo->ubicarPrimero();
    for(int i =0; i < cantRegistros; i++) {
        Registro* registro = *it;
        Distrito* d = (Distrito*)registro->getContenido();
        cout << d->getDistrito() << endl;
        delete d;
        it++;
    }
}

void BaseDeDatos::cargarBufferDesdeArchivo(){
    fstream bdfile;
    bdfile.open(ARCHIVO_BASE, ios_base::in | ios_base::binary);
    if (!bdfile.is_open()){
        bdfile.open(ARCHIVO_BASE, ios_base::in| ios_base::binary | ios_base::trunc);
    }
    while(!bdfile.eof() && !this->bufferLleno()) {
        Registro r;
        t_registro tr;
        if(bdfile.read((char*)(&tr), Registro::getSize()) ){
        	r.crearDesdeRegistro(tr);
        	this->bufferRegistros.push_back(r);
        } else {
        	break;
        }
    }
    bdfile.close();
}