[C++/STL]Ricerca

[Luc@s]

Mi sto facendo una mia lib comene x tutti i miei programmi, che sia il + possibili portabile.
Sto facendo la generica classe CParse per caricare files di conf.
Questa sara la base x CCOnfigParse.

// Parse.hpp
#ifndef PARSE_HPP_
#define PARSE_HPP_
#include "Define.hpp"
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cstring>

using namespace std;

N_BEG
/**
  <b>Name</b>:<i>CParse</i>  \n
  <b>Author</b>:<i>Kleidemos</i> \n
  <b>Description</b>:<i>Parserizza una configurazione generica</i>  \n
  Indicata come base per sviluppi \n
*/
class CParse
{
    friend CParse& operator+=(CParse &p, string _add);
        public:
                CParse() { _buf = " "; };
                CParse(string buf){ _buf = buf; };
                CParse(char * buf){ _buf = buf; };
                ~CParse();
                /// Read a generic config
                void Read(istream &is = cin, string * buf_r = "");
                /// Write a generic config
                void Write(ostream &os = cout, string buf = " ");
                /// Add a text
                inline void Add(string add) { _buf += add; };
                /// Find a info
                string Find(string info);
        private:
                string _buf;        
};
N_END

#endif

Questo è la sua dichiarazione.
Ho implementato +=, Write, Add.
Ma nn so come implementare Find.
Questo metodo dovrebbe cercarmi nel buffer caricato con Read(ancora da sistemare) un determinato valore(tipo file ini opt=valore).
Ma nn so come implementarla
Al momento ho implementato solo un metodo per sapere se è un files di config o no.

 
/**
  <b>Name</b>:Find\n
  <b>Return</b>L'informazione trovata\n
  <b>Argoments</b>:L' informazione da cercare\n
  <b>Description</b>:Find a info\n
*/
string CParse::Find(string info)
{
    const string CONFIG_MARK = "[CONFIG]";
    if(_buf.substr(0, CONFIG_MARK.size()) == CONFIG_MARK){
       /// TODO
       string::size_type val;
       val = _buf.find(info, 0 );
       if(val != string::npos){// trovata
              string ret;
              
       }else{// non trovata
              return "Error!\n";
       }

    }else{
        return "Error!\n";
    }
}

[cionci]

Scusa, ma se carichi già il file in memoria non ti conviene già caricarlo sotto forma di Sezione, Voce, Valore ?

[Luc@s]

string CParse::Find(string info)
{
    const string CONFIG_MARK = "[CONFIG]";
    if(_buf.substr(0, CONFIG_MARK.size()) == CONFIG_MARK)
    {
       /// TODO
       string::size_type val;
       val = _buf.find(info, 0 );
       if(val != string::npos){// trovata
              string ret;
              string::size_type equals = pos+1;
              if(info.at(equals) == "=")
              {
                  string::size_type fin = _buf.find(";", 0 );// fine dell'info
                  if(fin != string::npos)
                  {
                      ret.assign(equals+1, fin);
                  }else{
                      ret = "Error!";
                  }
              }
              
       }else{// non trovata
              ret = "Error!";
       }

    }else{
        ret = "Error!";
    }
    return ret;
}

Una cosa simile?

Pero nn mi va

[cionci]

Originariamente inviato da Luc@s
Pero nn mi va

Ripeto: carica prima i dati sequenzialmente in un vector di struct che contengono sezione, nome e valore (sarebbe carino anche un map di map, in questo modo avresti accesso alleinformazioni direttamente con i nomi della sezione e del nome della voce, comunque parti rpima dal vector di struct)...

[fek]

Segui il consiglio di cionci. Mentre leggi il file, organizzalo gia' in sezioni e chiavi, fai un parsing e poi la ricerca diviene banale.

Un paio di noticine sul codice:

Originariamente inviato da Luc@s

    friend CParse& operator+=(CParse &p, string _add);

Non usare un operatore in questo caso. Anche se sembra piu' elegante poter scrivere:

parse += std::string("una stringa");

Questa soluzione e' meno leggibile dell'equivalente:

parse.add(std::string("una stringa"));

In generale evita di usare metodi operatore e se proprio devi usarli, disegna il metodo di modo che si comporti in maniera naturale, in altre parole "fai come farebbero gli interi".

Ad esempio:
a += b
si deve comportare come:
a = a + b

perche' e' cio' che un qualunque programmatore si aspetterebbe leggendo il tuo codice. Ricordati che devi sempre programmare tenendo presente che qualcuno potra' leggere il tuo codice e deve essere in grado di capirlo il piu' velocemente possibile.

Un'altra nota, invece di passare il parametro _add come stringa per valore, passalo come const reference:
friend CParse& operator+=(CParse &p, string const& _add);

Altrimenti ti tocchera' pagare con l'inutile costruzione e distruzione di un oggetto temporaneo ogni volta che invochi il metodo. E la costruzione e distruzione di una stringa sono operazioni piuttosto costose. Occhio quando usi STL perche' se non sai esattamente quello che stai facendo, tende a diventare mooooooooolto lenta.

[verloc]

Come giustamente fatto rilevare da Cionci il problema è mal-impostato.

Devo avvertirti che l'errrore concettuale che credo tu faccia è nell'adoperare gli algoritmi standard (find):

nel 99% dei casi non restituiscono una posizione ma un iteratore (cosa assai diversa).

inoltre la std string ha anche i suoi algoritmi speciali che spesso sostituiscono quelli standard e che vengono implementati come
metodi propri.

Non so se sono stato chiaro

[Luc@s]

Risolto:

 // Parse.hpp
#ifndef PARSE_HPP_
#define PARSE_HPP_

#include "Define.hpp"

#include <cstdio>
#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
#include <cstring>

using namespace std;

N_BEG

/**
  <b>Name</b>:<i>SInfo</i>  \n
  <b>Author</b>:<i>Kleidemos</i> \n
  <b>Description</b>:<i>Configurazione</i>  \n
*/
typedef struct SInfo
{
	string key;
	string value;
} Info;


/**
  <b>Name</b>:<i>CParse</i>  \n
  <b>Author</b>:<i>Kleidemos</i> \n
  <b>Description</b>:<i>Parser classs for generic text</i>  \n
*/
class CParse
{
        public:
                CParse(){ _filename = "prog.conf"; };
                CParse(string name){ _filename = name; };
                CParse(char * name){ _filename = name; };
                ~CParse(){};
                virtual void Read(char separator = 'v');
                virtual void Write(char separator = 'v', string key = "", string value = "");
		    void Test();
		    virtual string Find(string key);
        private:
                string _filename;
                string _buf;
                vector<Info> conf;        
};

N_END

#endif

// Parse.cpp

#include "Parse.hpp"

N_BEG
/**
  <b>Name</b>:Read\n
  <b>Return</b>: -\n
  <b>Argoments</b>: A separator [ DEFAULT: v ] \n
  <b>Description</b>:Puts a generic config into internal buffer\n
*/
void CParse::Read(char separator)
{
	ifstream IN(_filename.c_str());
	char code;
	string key, value;
	Info inf;
	while(IN)
	{
		IN >> code;
		if(code == separator) // a key find
		{

			IN >> key >> value;		
			inf.value = value;
			inf.key = key;
			conf.push_back(inf);
		}
		else
		{
			key = " ";
			value = " ";
			// conf.push_back(inf);
		}
	}
	IN.close();
}
/**
  <b>Name</b>:Write\n
  <b>Return</b>:-\n
  <b>Argoments</b>: 
  - The name of options 
  - The value\n
  - A separator [ DEFAULT: v ]

  <b>Description</b>:Write a generic config value
*/
void CParse::Write(char separator, string key, string value)
{
	ofstream OUT(_filename.c_str(), ios::app);
	OUT << separator << " " << key << " " << value << "\n";
	OUT.close();
}
/**
  <b>Name</b>:Find\n
  <b>Return</b>:A Value of option\n
  <b>Argoments</b>: The name of option \n
  <b>Description</b>: Findo a option\n
*/
string CParse::Find(string key)
{
	string ret;
	vector<Info>::iterator It = conf.begin();
	for(; It != conf.end();++It)
	{
		if(It->key == key)
			ret = It->value;
	}
	return ret;
}
/**
  <b>Name</b>:Test\n
  <b>Return</b>:-\n
  <b>Argoments</b>: -
  <b>Description</b>: Test the class\n
  <b>ONLY FOR DEBUG</b>
*/
void CParse::Test()
{
	// Inserting
	Write('v', "prova", "si"); // write prova
	Write('v', "provas", "no");// write provas
	Write('v', "Schermo", "1024x768");// write Schermo
    Write('n', "Schermos", "1024x768");// write error value
	// Reading
	Read('v'); // puts read file
	// Printing
	typedef vector<Info>::iterator It;
	It it = conf.begin(); 
	for(;it != conf.end();++it) // iterator
	{
		cout << it->key << " => " << it->value << "\n"; 
	}
	// Finding
	cout << "Finding prova => " << Find("prova") << "\n";
	cout << "Finding provas => " << Find("provas") << "\n";
	cout << "Finding Schermo => " << Find("Schermo") << "\n";
	cout << "Finding Schermos => " << Find("Schermos") << "\n";// try to find error value
	
}

N_END

[cionci]

Sì..ora va bene...

[Luc@s]

Originariamente inviato da cionci
Sì..ora va bene...

davvero?
E migliorabile???


P.S: è portabile???