[Resolvido] [Código] Arquivos de configuração

[VictorCacciari 42]

Boas Pessoal!

Outro dia eu me lembrei como é boa a classe TINIfile do delphi...(hahahahaha)

e fiz uma coisa parecida, é bem simples, mas facilitou a minha vida.

 

#include <fstream>
#include <vector>
#include <sstream>

/*
Carregador de arquivos de configuração.
Victor Cacciari Miraldo

Como funciona?
tenha um arquivo de configuração da seguinte forma:
(sem espaços)

	nome_do_campo=valor_do_campo

para carregar um valor do tipo int, por exemplo:

	confile ff;
	int valor;

		ff.confOpen("seu_arquivo");

		//o segundo parametro, é o valor padrão.
		//ele é retornado quando não é encontrado nada com "nome_do_campo", ou quando ocorre algum erro.
		valor = ff.confRead<int>("nome_do_campo", 0);
		ff.confClose();

 */

class confile
{
	public:
		confile();
		~confile();

		void confOpen(char*);
		void confClose();

		template<class T>
		T confRead(char*, T);

	private:
		std::ifstream file;
		char* fpath;

		template<class T>
		T from_string(std::string);
		std::string f_findLine(char*);

};

confile::confile()
{
}
confile::~confile()
{
}

void confile::confOpen(char* path)
{
	file.open(path);
	fpath = path;
	if (!file.is_open())
		throw 400;
}

void confile::confClose()
{
	if (file.is_open())
		file.close();
}

//é aqui onde procuramos a linha que contém lbl
std::string confile::f_findLine(char* lbl)
{
std::string aux="";

	//é necessário fazermos um clear, para limpar todas as flags do arquivo.
	file.clear();
	file.seekg(0, std::ios::beg);

	while (!file.eof()) {
		std::getline(file, aux);
		//se compararmos lbl, com os primeiros (strlen(lbl)) da linha, e o resultado for 0, encontramos a linha
		if (strncmp(lbl, aux.c_str(), strlen(lbl))==0) {
			return aux;
		}
	}


	//se chegamos até aqui, é pq não encontramos a linha, retorna-se o padrão
	return "";
}

//essa função é apenas para fazer a conversão de string para T
template<class T>
T confile::from_string(std::string ss)
{
T vl;
std::stringstream stream;

	stream.str(ss);
	stream >> vl;
	return vl;

}

template<class T>
T confile::confRead(char* label, T def)
{
std::string line="", aux;
int i;

	//se não encontrarmos o valor, retorna-se o valor default
	line = f_findLine(label);
	if (line == "") return def;


	//se existir algum erro na sintaxe, também será retornado o valor default
	i=line.rfind('=')+1;
	if (i==std::string::npos) return def;

	aux = line.substr(i, line.length());

	return from_string<T>(aux);


}

template<>
char* confile::confRead<char*>(char* label, char* def)
{
std::string line="", aux;
char* linevl;
int i;

	//se não encontrarmos o valor, retorna-se o valor default
	line = f_findLine(label);
	if (line == "") return def;

	//se existir algum erro na sintaxe, também será retornado o valor default
	i=line.rfind('=')+1;
	if (i==std::string::npos) return def;

	aux = line.substr(i, line.length());

	//poderiamos retornar aux.c_str(), mas ai seria um const char*, e eu odeio consts...hahaha
	linevl = new char[aux.length() +1];
	strcpy(linevl, aux.c_str());

	return linevl;


}