void Parser::obtenerAutorTitulo(string nombre)
{
unsigned int posBarra = nombre.find_last_of("/\\");
nombre.erase(0, posBarra+1);
unsigned int posGuion = nombre.find('-',0);
string autor = nombre.substr(0,posGuion - 1);
string titulo = nombre.substr(posGuion + 1, nombre.length() - posGuion - 5);
this->autor = Util().toLower(Util().trim(autor));
this->titulo = Util().toLower(Util().trim(titulo));
}
void Parser::obtenerEditorial()
{
string rutaEd = Parametros().getParametro(ARCHIVO_EDITORIALES);
list<string> editoriales;
fstream arcEd;
arcEd.open(rutaEd.c_str(), ios::binary | ios::in);
if (arcEd.is_open())
{
levantarCSV(&arcEd,&editoriales);
arcEd.close();
}
unsigned int factor = atoi(Parametros().getParametro(FACTOR_EDITORIALES).c_str());
if (factor == 0)
factor = 1;
unsigned int nroEditorial = (((unsigned int)(this->autor.at(0))) - 97)/factor; // en ascii a = 97
unsigned int i = 0;
for (list<string>::iterator it = editoriales.begin(); it != editoriales.end(); it++ )
{
if (i == nroEditorial)
{
this->editorial = Util().toLower((*it));
break;
}else
i++;
}
}
Web::Web()
{
root = NULL;
curr = NULL;
myUtil = Util();
outFile = fopen("out.log", "w");
functionMap = new FMap();
}
void Parser::procesarPalabra(string palabra, set<string>* palabras)
{
//reemplaza los inavalidos por espacios
unsigned int pos = palabra.find_first_of(INVALIDOS);
while (pos != string::npos)
{
palabra[pos] = ' ';
pos = palabra.find_first_of(INVALIDOS, pos+1);
}
//reemplaza los \n por espacios
for (unsigned int j = 0; j < palabra.size();j++)
if (palabra.at(j) == '\n' || palabra.at(j) == '\r' || palabra.at(j) == '\0')
palabra[j] = ' ';
//cambia tilde
palabra = Util().sinTilde(palabra);
//a minuscula
palabra = Util().toLower(palabra);
//saco espacios al pricipio y al final
palabra = Util().trim(palabra);
if (palabra.size() != 0)
{
//analiza si quedaron dos o mas palabras (ejemplo: www fi uba ar)
//quedo un espacio en el medio
//esto funciona por que antes hice el trim
unsigned int posFin = palabra.find(' ',0);
string palabraLimpia;
while (posFin != string::npos)
{
palabraLimpia = palabra.substr(0,posFin+1);
this->guardarPalabra(palabraLimpia, palabras);
palabra.erase(0,posFin+1);
posFin = palabra.find(' ',0);
}
this->guardarPalabra(palabra, palabras);
} //palabra.size() != 0
}
void Util(struct Node *root,struct Node **head_ref)
{
if(root==NULL)
return;
Util(root->left,head_ref);
if(myprev==NULL)
{
*head_ref=root;
}
else
{
root->left=myprev;
myprev->right=root;
}
myprev=root;
Util(root->right,head_ref);
}
ArbolBMasNumerico::ArbolBMasNumerico(string path,
unsigned int tamanioBloque) :
ArbolBMas(path, tamanioBloque) {
this->archivoNodos = new ArchivoBloques(path, tamanioBloque);
this->tamanioNodo = tamanioBloque;
if (Util().existeArchivo(path)){
raiz = obtenerBloque(0);
}
else{
raiz = new Bloque();
guardarBloque(raiz, 0);
}
ultimaHojaVisitada = raiz;
}
int Servicios::agregarVarios(string cuantos)
{
int corte = atoi(cuantos.c_str());
string rutaLibros = Parametros().getParametro(CARPETA_LIBROS);
list<string> *archivos = Util().getArchivos(rutaLibros);
int cont = 0;
for (list<string>::iterator it = archivos->begin(); it != archivos->end(); it++)
{
cont++;
string pathAbs = rutaLibros + *it;
cout << "Agregando Texto: " << *it << "..." <<endl;
Servicios().tomarTexto(pathAbs);
if (cont >= corte) break;
}
return 0;
}
//************************************************
//************************************************
Serial_service::Serial_service(HardwareSerial& _serial, Xapi& _xapi, LCD_service& _lcd):
m_serial(_serial), m_xapi(_xapi), m_lcd(_lcd)
{
m_util = Util();
reset_rx_state();
}
void BToDLL(struct Node *root,struct Node **head_ref)
{
Util(root,head_ref);
myprev=NULL;
}
/*
* ShowGLMult.cpp
*
* Created on: 28/01/2015
* Author: pedro
*/
#include "ShowGLMult.h"
DetectorMult ShowGLMult::detector = DetectorMult();
Util ShowGLMult::util = Util();
int ShowGLMult::MODOS = 0;
vector<ObjetoMult> ShowGLMult::objetos = vector<ObjetoMult>();
vector<ObjetoMult> ShowGLMult::ultimasPosicoes = ShowGLMult::objetos;
Kalman ShowGLMult::kalman = Kalman();
ObjetoMult ShowGLMult::endGame = ObjetoMult();
bool ShowGLMult::gameOver = false;
ShowGLMult::ShowGLMult(DetectorMult& detector,vector<ObjetoMult> objetos, ObjetoMult& endGame){
if(objetos.size() == detector.getBoards().size()){
ShowGLMult::detector = detector;
ShowGLMult::objetos = objetos;
ShowGLMult::endGame = endGame;
for(unsigned int i=0;i<objetos.size();i++)
ShowGLMult::objetos.at(i).setConfig(ShowGLMult::detector.getBoards().at(i));
ShowGLMult::ultimasPosicoes = ShowGLMult::objetos ;
}
}
void ShowGLMult::ativarIluminacao(){
float luzAmbiente[]={0.2,0.2,0.2,1.0};
float luzDifusa[]={0.9,0.7,0.7,1.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;
}
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;
}
