#ifndef __FILE_H__
#define __FILE_H__
# include <iostream>
# include <stdio.h>
# include <fstream>
# include <string>
# include <sstream>
# include <windows.h>
# include <math.h>
using namespace std;
bool ViaLibera;
int ID;
string punt;
string Svet[250];
int Ppunt[250];
string Clog[250];
class File
{
public:
void ApriFileInScrittura(string NomeFile)
{
ofstream write(NomeFile.c_str(), ios::app);
}
/************************************FINE**************************************/
void GeneraID(string NomeFile)
{
ifstream trovaID("ID.txt", ios::in); //ID.txt file contentente il numero // dell'ultimo ID inserito
if (trovaID)
{
trovaID >> ID;
ID=ID+1;
trovaID.close();
}
else
ID=1;
ofstream write(NomeFile.c_str(),ios::app);
////// SCRIVI ID////////////
stringstream s; //
string ss; //
s << ID ; //
ss = s.str(); // /* Dimesione dell' ID = 5
ss.resize(5); // dato che ss.resize(5); */
write <<ss<<";";//
//////////////////////
write <<"L;"; /* Imposta FLAG per la CANCELLAZIONE LOGICA*/
write.close();
// Aggiorna L'ID che viene scritto sul file ID.txt
ofstream aggID("ID.txt", ios::out);
aggID << ID;
aggID.close();
}
/************************************FINE**************************************/
void ScriviCampo(string NomeFile, string Campo, int DimCampo)
{
ofstream write(NomeFile.c_str(),ios::app);
Campo.resize(DimCampo);
write << Campo;
write.close();
}
/************************************FINE**************************************/
void ScriviUltimoCampo(string NomeFile, string Campo, int DimCampo)
{
ofstream write(NomeFile.c_str(),ios::app);
Campo.resize(DimCampo);
write << Campo << endl;
write.close();
}
/************************************FINE**************************************/
void ScriviCampoChiavePrimario(string NomeFile, string NomeFileChiave ,string Campo, int DimCampo)
{
string controllo;
ifstream leggi(NomeFileChiave.c_str(), ios::in);
if (leggi)
{
while(!leggi.eof())
{
getline(leggi,controllo,';');
getline(leggi,controllo,'\0');
getline(leggi,punt,'\n');
if (controllo==Campo)
{
cout << "Questo e' un campo chiave gia assegnato" << endl;
cout << "Scegline un'altro" << endl;
ViaLibera=true;
}
}
}
if (ViaLibera==false && !leggi)
{
int puntatoreID=ID-1;
ofstream write(NomeFileChiave.c_str(),ios::app);
Campo.resize(DimCampo);
write << " ;" << Campo;
string idf=Dimensiona(puntatoreID,3);
write << ";"<< idf << endl;
write.close();
ofstream scrivi(NomeFile.c_str(),ios::app);
scrivi << Campo;
scrivi.close();
}
}
/************************************FINE**************************************/
void ScriviChiaveSecond(string NomeFile, string NomeFileChiaveSecondario, string Campo, int DimCampo)
{
ofstream scrivi(NomeFileChiaveSecondario.c_str(),ios::app);
Campo.resize(DimCampo);
scrivi << " ;" << Campo;
string idf=Dimensiona(ID-1,3);
scrivi << ";" << idf << endl;
scrivi.close();
ofstream write(NomeFile.c_str(), ios::app);
write << Campo;
write.close();
}
/************************************FINE**************************************/
void ScriviUltimoCampoChiaveSecond(string NomeFile, string N_F_UltimoCampo, string Campo, int DimCampo)
{
ofstream write(N_F_UltimoCampo.c_str(),ios::app);
Campo.resize(DimCampo);
write << " ;" << Campo;
string idf=Dimensiona(ID-1,3);
write << ";" << idf << endl;
write.close();
ofstream scrivi(NomeFile.c_str(),ios::app);
scrivi << Campo << endl;
scrivi.close();
}
/************************************FINE**************************************/
void CancellazioneLogica(string NomeFile ,int id)
{
bool trova=false;
string IDcanc,restorecord;
string ID=Dimensiona(id,5);
int k=0;
int q=GrandezzaRecord(NomeFile.c_str());
fstream r_w(NomeFile.c_str(), ios::in | ios::out);
ID.resize(5);
while(!r_w.eof())
{
getline(r_w,IDcanc,';');
if (ID==IDcanc)
{
trova=true;
fstream write(NomeFile.c_str(), ios::in | ios::out);
write.seekp((k*q)+6,ios_base::beg);
write <<"X";
write.close();
cout << "Record Cancellato!."<< endl;
}
getline(r_w,restorecord,'\n');
k++;
}
if (trova==false)
cout << "ID da cancellare non trovato nel file" << endl;
}
/************************************FINE**************************************/
void CancellazioneLogicaChiave(string NomeFileChiave, int id , int DimChiave)
{
int x= GrandezzaRecord(NomeFileChiave.c_str());
int rig=0,puntatore,riga;
bool trov=false;
fstream r_w(NomeFileChiave.c_str(),ios::in | ios::out);
if (r_w)
{
while(!r_w.eof())
{
r_w.seekp((x*rig)+DimChiave+3,ios_base::beg);
r_w >> puntatore;
puntatore++;
if (puntatore==id)
{
riga=rig;
trov=true;
}
rig++;
}
r_w.close();
if (trov==true)
{
fstream scrivi(NomeFileChiave.c_str(),ios::in | ios::out);
scrivi.seekp((x*riga),ios_base::beg);
scrivi << "X";
scrivi.close();
}
else
cout << "Id del file da cancellare non presente!" << endl;
}
else
cout << "Impossibile aprire il file "<<NomeFileChiave.c_str()<< endl;
}
/************************************FINE**************************************/
void StampaFile(string NomeFile)
{
system("CLS");
string Flag,Riga,IDRiga;
int k=0;
int q=GrandezzaRecord(NomeFile.c_str());
ifstream read(NomeFile.c_str(),ios::in | ios::out);
if (read)
{
while(!read.eof())
{
getline(read,IDRiga,';');
IDRiga.resize(5);
//ad.seekg(k*q+6,ios_base::beg);
getline(read,Flag,';');
getline(read,Riga,'\n');
if (Flag=="L")
{
cout << IDRiga;
cout << Riga << endl;
}
Flag=".";
k++;
}
}
}
/************************************FINE**************************************/
void SequencialSearch(string NomeFilePrincipale, string NomeFileChiave, string Campo)
{
string confronto,Riga,Riga2,resto,ctr;
int ID,puntID;
int x=GrandezzaRecord("PROVA.txt");
bool trova=false;
system("CLS");
fstream read(NomeFileChiave.c_str(),ios::in | ios::out);
if (read)
{
while(!read.eof())
{
getline(read,ctr,';');
getline(read,confronto,'\0');
getline(read,resto,';');
read >> puntID;
getline(read,resto,'\n');
if (confronto==Campo)
{
if (ctr!="X")
{
trova=true;
ID=puntID;
fstream leggi(NomeFilePrincipale.c_str(),ios::in | ios::out);
leggi.seekp(x*ID, ios_base::beg);
getline(leggi,Riga,';');
leggi.seekp((x*ID)+8,ios_base::beg);
getline(leggi,Riga2,'\n');
cout << Riga << Riga2 << endl;
leggi.close();
}
}
confronto="";
}
read.close();
}
else
cout << "File :"<<NomeFileChiave.c_str()<<" NON TROVATO!" << endl;
if(trova==false)
cout << "Campo da ricercare non presente nel File\n" << endl;
}
/************************************FINE**************************************/
void BinarySearch(string NomeFile, string NomeFileChiave , string Campo, int DimChiave)
{
// Da utilizzare per trovare un campo UNIVOCO
system("CLS");
string ricerca,continuo,ctr,stringa,stringa1;
bool esci=true,trovat=false;
OrdinaFileChiave(NomeFileChiave.c_str(), DimChiave);
int x = FileSize(NomeFileChiave.c_str());
int gr = GrandezzaRecord(NomeFileChiave.c_str());
int Rinf,Rsup,punta,punt,i,puntatore,puntabyte;
Rinf = 0;
i = 0;
Rsup = x/gr;
int N_acces = CalcLog(Rsup);
fstream read(NomeFileChiave.c_str(), ios::in | ios::out);
do
{
if (read)
{
punta=(Rinf+Rsup) / 2;
puntabyte= gr*punta;
read.seekp(puntabyte,ios_base::beg);
getline(read,ctr,';');
getline(read,ricerca,'\0');
getline(read,continuo,';');
read >> punt;
if (Campo>ricerca)
Rinf = punta;
else
if (Campo<ricerca)
Rsup=punta;
else
{
if (ctr!="X")
{
esci=false;
trovat=true;
puntatore=punt;
}
}
i++;
if (i>N_acces)
esci=false;
}
}
while(esci);
if (trovat==true)
{
int gr1 = GrandezzaRecord(NomeFile.c_str());
gr1=gr1*puntatore;
fstream leggi(NomeFile.c_str(),ios::in | ios::out);
leggi.seekp(gr1, ios_base::beg);
getline(leggi,stringa,';');
leggi.seekp((gr1)+8,ios_base::beg);
getline(leggi,stringa1,'\n');
cout << stringa << stringa1 << endl;
}
else
cout << "Campo da ricercare non TROVATO!. " << endl;
}
/************************************FINE**************************************/
void ModificaCampo(string NomeFile, int id,int pos, int DimCampo)
{ // Modifica di un campo NORMALE
string Modificato;
char y = TrovaFlag(NomeFile.c_str(),id);
if (y=='L')
{
cout << "Inserisci il campo modificato: ";
cin.sync();
getline(cin,Modificato);
Modificato.resize(DimCampo);
fstream write(NomeFile.c_str(),ios::in | ios::out);
int x=GrandezzaRecord(NomeFile.c_str());
id=id-1;
write.seekp((id*x)+pos,ios_base::beg);
write << Modificato;
write.close();
}
else
{
system("CLS");
cout << "Impossibile modificare!" << endl;
cout << "Il record e' stato cancellato logicamente" << endl<< endl;
cout << "Premi INVIO per continuare" << endl;
getchar();
getchar();
}
}
/************************************FINE**************************************/
void AggiungiQuantita(string NomeFile, float agg, int id, int pos, int DimCampo)
{
float quant;
string campo;
id = id - 1;
int x=GrandezzaRecord(NomeFile.c_str());
fstream r_w(NomeFile.c_str(), ios:: in | ios:: out);
r_w.seekp((id*x)+pos,ios_base::beg);
r_w >> quant;
quant=quant+agg;
r_w.seekp((id*x)+pos,ios_base::beg);
campo = Dimensiona(quant,DimCampo);
r_w << campo;
r_w.close();
}
/************************************FINE**************************************/
private:
int FileSize(const char* sFileName)
{
std::ifstream f;
f.open(sFileName, std::ios_base::binary | std::ios_base::in);
if (!f.good() || f.eof() || !f.is_open()) { return 0; }
f.seekg(0, std::ios_base::beg);
std::ifstream::pos_type begin_pos = f.tellg();
f.seekg(0, std::ios_base::end);
return static_cast<int>(f.tellg() - begin_pos);
}
/************************************FINE**************************************/
string Dimensiona(float Num, int DimCampo)
{
stringstream s;
string Id;
s << Num;
Id = s.str();
Id.resize(DimCampo);
return Id;
}
/************************************FINE**************************************/
int GrandezzaRecord(string NomeFile)
{
string InteraRiga;
int dim;
ifstream apri(NomeFile.c_str(), ios::in);
if (apri)
{
getline(apri,InteraRiga,'\n');
dim=InteraRiga.size()+2;
}
else
cout << "File "<<NomeFile.c_str()<<" non trovato! "<< endl;
return dim;
}
/************************************FINE**************************************/
char TrovaFlag(string NomeFile, int id)
{
char flag;
int x=GrandezzaRecord(NomeFile.c_str());
id--;
fstream read(NomeFile.c_str(), ios::in | ios::out);
if (read)
{
read.seekp((x*id)+6,ios_base::beg);
read >> flag;
}
else
cout << "Flag non trovato" << endl;
return flag;
}
/************************************FINE**************************************/
void OrdinaFileChiave(string NomeFile, int DimChiave)
{
string app,continuo,pun;
int i=0,il,iv,app1,salva;
int dim=GrandezzaRecord(NomeFile.c_str());
string resto,appoggio,scrivi;
fstream read(NomeFile.c_str(),ios::in | ios::out);
if (read)
{
while(!read.eof())
{
read.seekp(dim*i , ios_base::beg);
getline(read,Clog[i],';');
getline(read,Svet[i],'\0');
read.seekp((dim*i)+DimChiave+3,ios_base::beg);
read >> Ppunt[i];
getline(read,continuo,'\n');
i++;
}
salva=i-1;
i--;
for (il = 0;il < i - 1; il++)
{
for (iv = il + 1; iv < i; iv++)
{
if (Svet[iv] < Svet[il])
{
appoggio = Svet[il];
Svet[il] = Svet[iv];
Svet[iv] = appoggio;
// nuovo
app = Clog[il];
Clog[il] = Clog[iv];
Clog[iv] = app;
//
app1= Ppunt[il];
Ppunt[il]= Ppunt[iv];
Ppunt[iv]= app1;
}
}
}
//Scrivi file ordinato:
ofstream write(NomeFile.c_str(),ios::out);
for (int k=0;k<salva;k++)
{
scrivi= Svet[k];
scrivi.resize(DimChiave);
write << Clog[k]<<";"<< scrivi;
write << ";";
int pp=Ppunt[k];
pun=Dimensiona(pp,3);
write << pun << endl;
}
write.close();
}
else
cout << "Impossibile aprire il file "<<NomeFile.c_str()<<" per ordinarlo!" << endl;
}
/************************************FINE**************************************/
int CalcLog (int num)
{
int result;
result = log2 (num);
return result;
}
/************************************FINE**************************************/
};
#endif