void principal::on_pushButton_5_clicked()
{
llenado n (ui->fechag->text(),ui->splp->value(),ui->splitro->value(),ui->spkilometro->value());
lista[::posicion]->setLista(n);
QMessageBox::about(this,"Se Cargo Gasolina al Carro con placa: ",ui->txtbusca->text());
QFile archivo1("/home/jossy/proyecto/llenados.txt");
archivo1.open(QIODevice::WriteOnly | QIODevice::Truncate);
QFile archivo("/home/jossy/proyecto/base09.txt");
archivo.open(QIODevice::WriteOnly | QIODevice::Truncate); //
QTextStream escribir(&archivo);
QTextStream escribir1(&archivo1);
for(int i=0; i<lista.size();i++){
QString txt= lista[i]->getplaca()+","+lista[i]->getmarca()+","+QString::number(lista[i]->getcilindraje());
escribir << txt <<endl;
QString subtxt =lista[i]->getplaca();
for(int r=0; r<lista[i]->getLista().size();r++){
subtxt +=lista[i]->getLista()[r].toString();
}
escribir1 << subtxt <<endl;
ui->pushButton_5->setEnabled(false);
}
archivo.close();
archivo1.close();
QMessageBox::about(this,"Control","Guardado con exito");
ui->txtbusca->setText("");
ui->splp->setValue(0);
ui->splitro->setValue(0);
ui->spkilometro->setValue(0);
}
void VentanaPrincipal::cargarArchivo(const QString &nombreArchivo)
{
QFile archivo(nombreArchivo);
if (!archivo.open(QFile::ReadOnly | QFile::Text))
{
QMessageBox::warning(this, tr("Sendero"),
tr("No se pudo abrir el archivo %1:\n%2.")
.arg(nombreArchivo)
.arg(archivo.errorString()));
return;
}
QTextStream flujoEntrada(&archivo);
#ifndef QT_NO_CURSOR
QApplication::setOverrideCursor(Qt::WaitCursor);
#endif
editorTexto->setPlainText(flujoEntrada.readAll());
#ifndef QT_NO_CURSOR
QApplication::restoreOverrideCursor();
#endif
setArchivoActual(nombreArchivo);
statusBar()->showMessage(tr("Archivo cargado"), 3000);
archivo.close();
}
bool VentanaPrincipal::guardarArchivo(const QString &nombreArchivo)
{
QFile archivo(nombreArchivo);
if (!archivo.open(QFile::WriteOnly | QFile::Text))
{
QMessageBox::warning(this, tr("Sendero"),
tr("No se pudo guardar %1:\n%2.")
.arg(nombreArchivo)
.arg(archivo.errorString()));
return false;
}
QTextStream flujoSalida(&archivo);
#ifndef QT_NO_CURSOR
QApplication::setOverrideCursor(Qt::WaitCursor);
#endif
flujoSalida << (editorTexto->toPlainText());
#ifndef QT_NO_CURSOR
QApplication::restoreOverrideCursor();
#endif
setArchivoActual(nombreArchivo);
statusBar()->showMessage(tr("Archivo guardado"), 2000);
archivo.close();
return true;
}
void VentanaPrincipal::actualizarVistaInformativa(QString ruta)
{
QFile archivo(ruta + ".lexemas");
if (!archivo.open(QFile::ReadOnly | QFile::Text))
return;
QTextStream flujo(&archivo);
delete modeloInformativa;
modeloInformativa = new QStandardItemModel(0, 2, this);
modeloInformativa->setHeaderData(0, Qt::Horizontal, QObject::tr("Token"));
modeloInformativa->setHeaderData(1, Qt::Horizontal, QObject::tr("Lexema"));
vistaInformativa->setModel(modeloInformativa);
int i = 0;
while(!flujo.atEnd())
{
QStringList tmp = flujo.readLine().split(",,,");
modeloInformativa->insertRow(i);
modeloInformativa->setData(modeloInformativa->index(i, 0), tmp[0]);
modeloInformativa->setData(modeloInformativa->index(i, 1), tmp[1]);
++i;
}
}
int MyDB::createDB(int tamanio, QString path){
qDebug()<<"#CREANDO NUEVA BD#";
QFile archivo(path);
if(!archivo.open(QIODevice::ReadWrite))
return 1;
this->header.tamanio=tamanio;
QString temp=this->getNameWithoutExtention(path);
this->header.setName(const_cast<char*>(temp.toStdString().c_str()));
this->header.setAuthors("Industrias BuenRecord");
qDebug()<<"\t#Size Header#"<<sizeof(Header);
this->header.countBlocksBitsMap=this->getBlockCant(tamanio*1024*1024,this->SIZE_BLOCK);
qDebug()<<"\t#Cantdad bloques disponibles#"<<this->header.countBlocksBitsMap;
this->header.sizeBitsMap=this->header.countBlocksBitsMap/8;
qDebug()<<"\t#Tamaño bitsmap(bytes)#"<<this->header.sizeBitsMap;
this->header.start_metaData=sizeof(Header)+this->header.sizeBitsMap;
this->header.size_metaData=this->getBlockCant(50*sizeof(MetaDataTable),this->SIZE_BLOCK)*this->SIZE_BLOCK;
qDebug()<<"\t#Tamaño metadata (bytes)#"<<this->header.size_metaData;
this->header.rellenoMetadata=this->header.size_metaData-(50*sizeof(MetaDataTable));
this->header.all_Header_size=sizeof(Header)+this->header.sizeBitsMap+this->header.size_metaData;
archivo.write(reinterpret_cast<char*>(&this->header),sizeof(Header));
QByteArray array(this->header.sizeBitsMap,'\0');
archivo.write(array);
for(int i=0;i<50;i++){
MetaDataTable metadat;
archivo.write(reinterpret_cast<char *>(&metadat),sizeof(MetaDataTable));
}
this->rellenar(this->header.rellenoMetadata,archivo);
qDebug()<<"\t#Tamaño total de los encabezados#"<<this->header.all_Header_size;
qDebug()<<"\t#Rellenando el archivo#";
this->rellenar(this->header.countBlocksBitsMap*1024,archivo);
archivo.close();
return 0;
}
int MyDB::createDB(int tamanio, QString path){
QFile archivo(path);
if(!archivo.open(QIODevice::ReadWrite))
return 1;
this->header.tamanio=tamanio;
QString temp=this->getNameWithoutExtention(path);
this->header.setName(const_cast<char*>(temp.toStdString().c_str()));
this->header.setAuthors("Industrias BuenRecord");
qDebug()<<"Bytes Header"<<sizeof(Header);
this->header.countBlocksBitsMap=this->getBlockCant(tamanio*1024*1024,this->SIZE_BLOCK);
qDebug()<<"cantidad de bloques vacios"<<this->header.countBlocksBitsMap;
this->header.sizeBitsMap=this->header.countBlocksBitsMap/8;
qDebug()<<"Bytes del Bitsmap"<<this->header.sizeBitsMap;
this->header.start_metaData=sizeof(Header)+this->header.sizeBitsMap;
qDebug()<<"Byte donde inicia la metadata"<<this->header.start_metaData;
qDebug()<<"tamanio de la MetaDataTable"<<sizeof(MetaDataTable);
this->header.size_metaData=this->getBlockCant(50*sizeof(MetaDataTable),this->SIZE_BLOCK)*this->SIZE_BLOCK;
qDebug()<<"Size metadata"<<this->header.size_metaData;
this->header.rellenoMetadata=this->header.size_metaData-(50*sizeof(MetaDataTable));
qDebug()<<"relleno MetaData"<<this->header.rellenoMetadata;
this->header.all_Header_size=sizeof(Header)+this->header.sizeBitsMap+this->header.size_metaData;
archivo.write(reinterpret_cast<char*>(&this->header),sizeof(Header));
QByteArray array(this->header.sizeBitsMap,'\0');
archivo.write(array);
for(int i=0;i<50;i++){
MetaDataTable metadat;
archivo.write(reinterpret_cast<char *>(&metadat),sizeof(MetaDataTable));
}
this->rellenar(this->header.rellenoMetadata,archivo);
qDebug()<<"xD"<<this->header.all_Header_size;
this->rellenar(this->header.countBlocksBitsMap*1024,archivo);
archivo.close();
return 0;
}
void principal::on_pushButton_8_clicked(){
QFile archivo1("/home/jossy/proyecto/llenados.txt");
archivo1.open(QIODevice::WriteOnly | QIODevice::Truncate);
QFile archivo("/home/jossy/proyecto/base09.txt");
archivo.open(QIODevice::WriteOnly | QIODevice::Truncate); //
QTextStream escribir(&archivo);
QTextStream escribir1(&archivo1);
for(int i=0; i<lista.size();i++){
QString txt= lista[i]->getplaca()+","+lista[i]->getmarca()+","+QString::number(lista[i]->getcilindraje());
escribir << txt <<endl;
QString subtxt =lista[i]->getplaca();
for(int r=0; r<lista[i]->getLista().size();r++){
subtxt +=lista[i]->getLista()[r].toString();
}
escribir1 << subtxt <<endl;
}
archivo.close();
archivo1.close();
QMessageBox::about(this,"Control","Grabado con exito");
}
// LOAD IMAGE
bool MainController::loadImage(QString filename){
if(!filename.contains("."))
{
ImageDCM *imageDCM = new ImageDCM();
if(imageDCM->convertToBMP(filename.toAscii()))
{
qImage=new QImage(filename+".pgm");
return true;
}else{
return false;
}
}else{
ImageFile archivo(filename); // Crear el objeto tipo Archivo
if(archivo.readImageContents()){
QString imageType = filename.right(3).toUpper(); // Obtener la extension de la imagen
qImage=new QImage(filename);
if(imageType == "PPM"){
imagenPPM = new ImagenPPM(archivo.getImageContents());
}else{
imagenPGM = new ImagenPGM(archivo.getImageContents());
}
return true;
}else{
return false;
}
}
}
int pruebaEstragiaCompresionAlmacenamiento(char nombre_archivo[]){
AtributoFijo<char*> nombre("N",10);
Registro registro(1,&nombre);
EARegistros estrategia(®istro);
Archivo archivo(&estrategia);
/*archivo original*/
archivo.crear(nombre_archivo);
for(int i=0;i<200;i++){
*(AtributoFijo<char*>*)registro.get(0)=Terminos::obtenerTermino(i).c_str();
((Almacenamiento&)archivo).escribir(®istro);
}
cout<<"/***************COMPRIMIENDO************************/"<<endl;
archivo.imprimir(cout);
archivo.cerrar();
EstrategiaCompresion compresion;
archivo.abrir(nombre_archivo);
compresion.compresion(&archivo,10);
archivo.cerrar();
/*creo un archivo para los descomprimidos*/
cout<<endl<<"/***************DESCOMPRIMIENDO************************/"<<endl;
remove(nombre_archivo);
archivo.crear(nombre_archivo);
compresion.descompresion(&archivo);
archivo.imprimir(cout);
archivo.cerrar();
return 0;
}
void comparacionEntropia (char *nombreFunc, char *nombreMalla) {
FuncionBayesVoronoiCBI *func = new FuncionBayesVoronoiCBI (nombreFunc);
Inicializador *ini = new InicializadorArchivo(nombreMalla);
int n = func->getNPars() / 3;
double *Ni = new double [n];
double *p = new double [func->getNPars()];
ini->inicializar (p, n);
std::ofstream archivo ("S_vs_quanta.dat");
archivo.close();
archivo.open ("S_vs_N.dat");
archivo.close();
double quanta, S, quanta_old, N;
for (int i = 0; i < n; i++) {
Ni[i] = p[3 * i + 2] / func->getRuido();
}
quanta_old = func->getRuido();
for (quanta = 1e-6; quanta < 1e3; quanta *= 2) {
N = 0;
for (int i = 0; i < n; i++) {
Ni[i] = Ni[i] * quanta_old / quanta;
N += Ni[i];
}
S = entropia (Ni, n);
archivo.open ("S_vs_quanta.dat", ios::app);
archivo << quanta << "\t" << -S << "\n";
archivo.close();
archivo.open ("S_vs_N.dat", ios::app);
archivo << N << "\t" << -S << "\n";
archivo.close();
quanta_old = quanta;
}
}
int ManejadorArchivosTexto::hallar_lineas(std::string nombreArchivo,std::string linea)const throw(){
if(!archivo_existe(nombreArchivo))
return RES_FILE_DOESNT_EXIST;
const unsigned short TAMANIO_BUFFER_CHAR= 1024;
char* bufferChar= new char[TAMANIO_BUFFER_CHAR];
std::ifstream archivo(nombreArchivo.c_str(),std::ios::in);
int posicionLinea= LINEAS_NO_HALLADAS;
std::string lineaString= linea;
while(archivo.good()){
archivo.getline(bufferChar,TAMANIO_BUFFER_CHAR);
if(archivo.good()){
std::string bufferString= bufferChar;
posicionLinea= bufferString.find(lineaString);
if(posicionLinea!= LINEAS_NO_HALLADAS)
std::cout<<bufferString<<std::endl;
}
}
archivo.seekg(0,std::ios::end);
archivo.close();
delete[] bufferChar;
return posicionLinea;
}/*halla lineas del archivo de texto donde se encuentra una linea especifica*/
void Agente::cargarDesdeArchivo(const std::string& rutaDatos) {
std::fstream archivo(rutaDatos.c_str(), std::fstream::in);
Consulta cons;
std::string linea;
std::string campo;
Utilitario util;
while (archivo.good() && _sck->conectado()) {
cons.limpiar();
cons.definirComoConsultaAgente();
leerLinea(archivo, linea);
if (linea.size() > 0) {
for (unsigned i = 0 ; i < Organizacion::cantidadCampos() ; i++) {
campo = util.separar(linea, TABULADOR, i);
cons.agregarCampo(campo);
}
this->enviarConsulta(cons);
}
}
this->recibirRespuesta();
}
void DataJson::readJson()
{
QFile archivo(QApplication::applicationDirPath()+"/dataAplicationToolsPcot.txt");
archivo.open(QFile::ReadOnly | QFile::Text);
QByteArray contenido=archivo.readAll();
archivo.close();
QJsonDocument fileJson=QJsonDocument::fromJson(contenido);
QJsonArray listaAmbitos=fileJson.array();
QJsonArray listaExe;
foreach (QJsonValue registro,listaAmbitos)
{
QJsonObject ambito=registro.toObject();
QString nAmbito=registro.toObject().value("Nombreambito").toString();
QString pathImage=registro.toObject().value("Path").toString();
if(nAmbito=="Catalunya lidar 2 metres")
{
setPathImageMetCat(pathImage);
existImageCat();
listaExe=ambito.value("Ejecutables").toArray();
foreach (QJsonValue exe,listaExe)
{
QString nExe=exe.toObject().value("Nombre").toString();
QString pathExe=exe.toObject().value("Path").toString();
if(nExe=="exeExtraction")setExeExtraction(pathExe);
else if(nExe=="exeResize")setExeResize(pathExe);
else if(nExe=="exeFootPrintMask")setExeFootPrintMask(pathExe);
else if(nExe=="exeSubScene")setExeSubScene(pathExe);
else setExeImaOpeGeo(pathExe);
existexeExtraction();
existexeResize();
existexeFootPrintMask();
existexeSubScene();
}
Element* Stack::pop()
{
fstream leer_archivo("Agenda.txt");
ofstream archivo("borrar.txt");
Contacto contacto;
leer_archivo.read((char *)&contacto, sizeof(contacto));
if(leer_archivo.fail())
{
cout <<" Ocurrio un ploblema, intentando abrir la agenda :(" <<endl;
exit(1);
}
while(!leer_archivo.eof())
{
if(contacto.id != id)
{
archivo.write((char *)&contacto, sizeof(contacto));
}
leer_archivo.read((char *)&contacto, sizeof(contacto));
}
cout << endl;
leer_archivo.close();
archivo.close();
remove("Agenda.txt");
rename("borrar.txt", "Agenda.txt");
}
//http://www.cplusplus.com/doc/tutorial/files/
void abrirArchivoBinario(char *nombre){
std::ifstream archivo (nombre, std::ios::in|std::ios::binary|std::ios::ate);
//objeto ifstream que indica que el archivo se abre para operaciones de lectura
//se le da permiso de escritura, se lee en modo binario y se posiciona el streaming al final del archivo
if (archivo.is_open()){
std::cout << "Leer el archivo en modo binario" << std::endl;
std::streampos size_file; //objeto que toma como referencia la posicion del streamin
//notar que si se posiciona el streaming al final del archivo entonces se puede saber su tam
size_file = archivo.tellg(); //indica la posicion actual del stream
std::vector<unsigned char> bytesArchivo;
bytesArchivo.reserve(size_file);
archivo.seekg(0, std::ios::beg);
unsigned char byte;
while (!archivo.eof()){ //mientras no se llegue al final del archivo
archivo >> byte; //stream en tal posicion guarda su valor en la variable caracter sin signo
//std::cout << byte << std::endl;
if (archivo.fail()){
break;
}
bytesArchivo.push_back(byte); //poner el byte en el vector de caracteres sin signo
}
//now i should have a vector of unsigned chars, right? well, i want to know what is in the vector of bytes
leerVector(bytesArchivo);
archivo.close();
}
int pruebaAlmacenamientoBufferCache(char nombre_archivo[] ){
AtributoVariable<string> nombre("N");
AtributoVariable<int> numeros("#");
AtributoFijo<int> num("n");
Registro registro(3,&nombre,&numeros,&num);
Bloque bloque(®istro);
Clave clave(®istro,1,"N");
ComparadorRegistroVariable comparador;
EABloques estrategia(&bloque,125,0.8f);
estrategia.setClave(&clave);
estrategia.setComparador(&comparador);
Archivo archivo(&estrategia);
AlmacenamientoBufferCache cache(&archivo,5);
/*archivo original*/
cache.crear(nombre_archivo);
for(int i=0;i<5;i++){
*(AtributoVariable<string>*)registro.get(0)=Terminos::obtenerTermino(i).c_str();
((AtributoVariable<int>*)registro.get(1))->getVector().clear();
for(int j=0;j< i%4+1;j++){
((AtributoVariable<int>*)registro.get(1))->getVector().push_back(j);
};
*((AtributoFijo<int>*)registro.get(2))=i;
if(not ((Almacenamiento&)cache).insertar(®istro))
cout<<"Problema"<<endl;
}
cache.imprimir(cout);
cache.cerrar();
archivo.setEstrategia(&estrategia);
archivo.abrir(nombre_archivo);
archivo.imprimir(cout);
archivo.cerrar();
return 0;
}
void DistribucionCondicionalCBI::guardarInfo (string info) {
// Para este caso usaremos info como el sufijo de los archivos a
// guardar.
string nombre_archivo;
nombre_archivo = "!MEM_CBI" + info + ".fits";
char *nombreC = new char [nombre_archivo.length() + 1];
nombre_archivo.copy(nombreC, string::npos);
nombreC [nombre_archivo.length()] = 0;
cout << "guardando " << nombreC << "\n";
do_write_fits (fg_image, nombreC);
delete [] nombreC;
nombre_archivo = "MEM_CBI" + info + ".dat";
nombreC = new char [nombre_archivo.length() + 1];
nombre_archivo.copy(nombreC, string::npos);
nombreC [nombre_archivo.length()] = 0;
cout << "guardando " << nombreC << "\n";
ofstream archivo (nombreC);
archivo << n_pars << "\n";
for (int i = 0; i < n_pars; i++) {
archivo << fg_image->pixels[i] << "\n";
}
delete [] nombreC;
}
void Jugador::guardar()
{
ofstream archivo("jugador.capy");
cout << "SAVING" << endl;
cout << "X: " << x << " Y: " << y << endl;
archivo << x << endl;
archivo << y << endl;
}
void Sudoku::guardarGanadores(){
QFile archivo("ganadores.txt");
if ( !archivo.open(QIODevice::WriteOnly)) {
QMessageBox::critical(this,"Error!","La partida no se pudo guardar");
} else {
QTextStream stream(&archivo);
stream << nombre;
stream.flush();
QMessageBox::information(this,"Solucionado!","Su nombre se ha guardado en la lista de ganadores!");
}
}
void TUAD::cargarTxtTUAD()
{
ifstream archivo("texto.txt");
char car;
int res;
while (!archivo.eof()){
car=archivo.get();
res=insertarTUAD(car);
}
archivo.close();
}
void InicializadorArchivo::inicializar (double pars[], int n, double init) {
std::ifstream archivo (nombre_archivo);
archivo >> n;
cout << "n = " << n << "\n";
for (int i = 0; i < n; i++) {
archivo >> pars [i];
}
archivo.close();
}
void comprobarDistribucionMemCBI (int argc, char ** argv) {
InicializadorArchivo *ini = new InicializadorArchivo (argv [3]);
DistribucionCondicionalMemCBI *dcMem1 = new DistribucionCondicionalMemCBI (argv[1], argv + 2, 1/*argc - 2*/,
new FuncionEntropiaNatural(64*64), 0, 51,
ini);
DistribucionCondicionalMemCBI *dcMem2 = new DistribucionCondicionalMemCBI (argv[1], argv + 2, 1/*argc - 2*/,
new FuncionEntropiaNatural(64*64), 0, 51,
ini);
dcMem1->guardarInfo("dcMem1");
double *p = new double [64*64];
ini->inicializar (p, 64*64);
for (int i = 0; i < 64*64; i++) {
p[i] /= dcMem1->getQuanta();
}
std::ofstream archivo ("ComprobacionDistribucion.dat");
archivo.close();
archivo.open ("distribCond1.dat");
archivo.close();
archivo.open ("distribCond1_x.dat");
archivo.close();
archivo.open ("distribCond2.dat");
archivo.close();
archivo.open ("distribCond2_x.dat");
archivo.close();
double dc1, dc2;
for (int i = 0; i < 64*64; i++) {
dc1 = dcMem1->evaluar (p, p[i] * 1.1, i);
dc2 = dcMem2->evaluar_old (p, p[i] * 1.1, i);
archivo.open ("ComprobacionDistribucion.dat", ios::app);
archivo << dc1 << "\t" << dc2 << "\n";
archivo.close();
archivo.open ("distribCond1.dat", ios::app);
archivo << p[i] << "\t" << dc1 << "\n";
archivo.close();
archivo.open ("distribCond2.dat", ios::app);
archivo << p[i] << "\t" << dc2<< "\n";
archivo.close();
archivo.open ("distribCond1_x.dat", ios::app);
archivo << i << "\t" << dc1 << "\n";
archivo.close();
archivo.open ("distribCond2_x.dat", ios::app);
archivo << i << "\t" << dc2 << "\n";
archivo.close();
}
}
void abrirArchivo(char *nombre){
std::ifstream archivo (nombre);
std::string line;
std::cout << "Existe archivo: " << nombre << ": " << existeArchivo(nombre) << std::endl;
if (archivo.is_open()){
std::cout << "Abrir: " << nombre << std::endl;
while ((getline (archivo, line))){
std::cout << "\t" << line << std::endl;
}
archivo.close();
}
else{
std::cout << "Incapaz de abrir" << std::endl;
}
}
void Sudoku::cargarPartida(){
SimpleCrypt crypto(Q_UINT64_C(0x0c2ad4a4acb9f023));
QFile archivo(":/recursos/partida.txt");
if (archivo.exists(":/recursos/partida.txt")){
archivo.open(QFile::ReadOnly);
QTextStream stream(&archivo);
QString crypt=stream.readAll();
QString linea=crypto.decryptToString(crypt);
pasarStringAMatriz(linea);
pasarMatrizAUI();
} else {
QMessageBox::critical(this,"Error","No existe el archivo ");
}
archivo.close();
}
bool dialog_nuevoRegistro::updateIndexFile2(){
//Guardar en el Indice
QFile archivo(header_file2.nombre_archivo + ".libx");
qDebug() << "Nombre Archivo" << header_file2.nombre_archivo;
if (!archivo.open(QIODevice::WriteOnly | QIODevice::Text))
return false;
QTextStream out2(&archivo);
QMapIterator<QString, QString> i(mw->index);
while (i.hasNext()) {
i.next();
qDebug() << "kEY" << i.key();
qDebug() << "Value " << i.value();
out2 << i.key() << "," << i.value() << endl;
}
archivo.close();
}
void MainWindow::on_pushButton_2_clicked()
{
try {
QString path(QFileDialog::getOpenFileName(this,tr("Abrir Archivo"), "./", tr("DAT Files (*.dat)")));
QFile archivo(path);
if (!archivo.exists()) {
return;
}
if (archivo.isOpen()) {
archivo.close();
}
DialogVer dialog(path,this);
dialog.exec();
} catch (...) {
}
}
void principal::on_pushButton_clicked()
{
bool Existe=false;
for(int i=0; i<lista.size();i++){
if(ui->placa->text()==lista[i]->getplaca()){
Existe=true;
}
}
if(Existe==true){
QMessageBox::about(this,"Control de Seguridad","Ya Existe Ese Numero de Placa");
}else{
if(ui->placa->text()=="" || ui->marca->text()==""){
QMessageBox::about(this,"Control de Seguridad","No debe dejar atributos vacios");
}else{
Carros* car = new Carros(ui->cilin->value(),ui->placa->text(),ui->marca->text(),"");
lista.push_back(car);
QFile archivo1("/home/jossy/proyecto/llenados.txt");
archivo1.open(QIODevice::WriteOnly | QIODevice::Truncate);
QFile archivo("/home/jossy/proyecto/base09.txt");
archivo.open(QIODevice::WriteOnly | QIODevice::Truncate); //
QTextStream escribir(&archivo);
QTextStream escribir1(&archivo1);
for(int i=0; i<lista.size();i++){
QString txt= lista[i]->getplaca()+","+lista[i]->getmarca()+","+QString::number(lista[i]->getcilindraje());
escribir << txt <<endl;
QString subtxt =lista[i]->getplaca();
for(int r=0; r<lista[i]->getLista().size();r++){
subtxt +=lista[i]->getLista()[r].toString();
}
escribir1 << subtxt <<endl;
}
archivo.close();
archivo1.close();
QMessageBox::about(this,"Control","Guardado con exito");
ui->placa->setText("");
ui->marca->setText("");
ui->cilin->setValue(2);
}
}
}
void generarMuestras (DistribucionPbb *d, char *nombreArchivo, int N) {
double *p = new double [d->getNPars()];
std::ofstream archivo (nombreArchivo);
archivo.close();
archivo.precision (8);
archivo << N << "\n";
for (int cont = 0; cont < N; cont++) {
if (cont % 1000 == 0) cout << "cont = " << cont << "\n";
d->generar (p);
archivo.open (nombreArchivo, ios::app);
for (int i = 0; i < d->getNPars(); i++) {
archivo << p[i] << "\t";
}
archivo <<"\n";
archivo.close();
}
}
/*!
* \fn EReporte::cargar( const QString nombre )
* Carga el reporte que es pasado como parametro.
* Si la base de datos cargado es SQLite intentará cargarlo desde la carpeta QApplication::applicationDirPath() / reportes.
* El nombre de archivo buscado será <nombre>.xml.
* Si la base de datos cargada no es SQLite, se intentará cargar los reportes desde la tabla "report" dentro de las tablas.
* El nombre del reporte deberá conincidir con el "report_name" de la tabla. Siempre se intentará cargar el numero de reporte mas alto.
* \param nombre Nombre del reporte que se desea cargar.
*/
bool EReporte::cargar( const QString nombre ) {
if( QSqlDatabase::database( QSqlDatabase::defaultConnection, false ).driverName() == "QSQLITE" ) {
// Tiene que estar en un archio xml guardado en un directorio
QDir reporte = QApplication::applicationDirPath();
if( ! reporte.cd( "reportes" ) ) {
qWarning( "No se pudo ingresar al directorio de reportes - Consulte el servicio tecnico" );
return false;
}
// busco el nombre de archivo
QString ruta = reporte.absoluteFilePath( nombre + ".xml" );
if( QFile::exists( ruta ) ) {
// Cargo el archivo como dato
qDebug( QString( "Cargando archivo %1" ).arg( ruta ).toLocal8Bit() );
// La librería no soporta archivos como parametro
QDomDocument *doc = new QDomDocument(_nombre);
QFile archivo(ruta);
if(!archivo.open(QIODevice::ReadOnly)) {
qDebug( "Error al intentar abrir el archivo como solo lectura" );
return false;
}
if( !doc->setContent( &archivo ) ) {
archivo.close();
qDebug( "Error al insertar el contenido del archivo en el documento DOM" );
return false;
}
archivo.close();
_rep = new orReport();
if( !_rep->setDom( *doc ) ) {
qDebug( "Error al setear el contenido del reporte con el documento DOM" );
return false;
}
} else {
qWarning( QString( "Error - No se pudo cargar el reporte - No existe el archivo %1" ).arg( ruta ).toLocal8Bit() );
return false;
}
} else {
// Para otros tipos de base de datos podemos accederlo en la base de datos
_rep = new orReport( nombre );
}
if( (!_rep == 0) && !_rep->isValid() ) {
qDebug( "Error - el reporte solicitado no es valido" );
_rep->reportError( 0 );
return false;
}
return true;
}
void Sudoku::on_actionGuardar_partida_triggered()
{
SimpleCrypt crypto(Q_UINT64_C(0x0c2ad4a4acb9f023));
if (QMessageBox::Yes == QMessageBox::question(this, "Guardar", "¿Desea guardar la partida actual?", QMessageBox::Yes|QMessageBox::No)){
pasarUIAMatriz();
QString linea=pasarMatrizAString();
QString crypted=crypto.encryptToString(linea);
QFile archivo(":/recursos/partida.txt");
if ( !archivo.open(QIODevice::WriteOnly)) {
QMessageBox::critical(this,"Error!","La partida no se pudo guardar");
} else {
QTextStream stream(&archivo);
stream << crypted;
stream.flush();
QMessageBox::information(this,"Guardado!","La partida se ha guardado con éxito");
}
}
}