tschum/LimitTool/Chameleon.h

#ifndef CHAMELEON_H
#define CHAMELEON_H


//---chameleon class

#include <sstream>
#include <string>
#include <map>
#include <fstream>
#include <string>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

class Chameleon {

  public:
Chameleon() {}
Chameleon(std::string const& value) {
  value_=value;
}


Chameleon(const char* c) {
  value_=c;
}

Chameleon(double d) {
  std::stringstream s;
  s<<d;
  value_=s.str();
}

Chameleon(Chameleon const& other) {
  value_=other.value_;
}

Chameleon& operator=(Chameleon const& other) {
  value_=other.value_;
  return *this;
}

Chameleon& operator=(double i) {
  std::stringstream s;
  s << i;
  value_ = s.str();
  return *this;
}

Chameleon& operator=(std::string const& s) {
  value_=s;
  return *this;
}

operator std::string() const {
  return value_;
}

operator double() const {
  return atof(value_.c_str());
}


private:
  std::string value_;
};


//---trim function
std::string trim(std::string const& source, char const* delims = " \t\r\n") {
  std::string result(source);
  std::string::size_type index = result.find_last_not_of(delims);
  if(index != std::string::npos)
    result.erase(++index);

  index = result.find_first_not_of(delims);
  if(index != std::string::npos)
    result.erase(0, index);
  else
    result.erase();
  return result;
}

//---trim function

//---class
class ConfigFile {
  std::map<std::string,Chameleon> content_;

public:
  ConfigFile(std::string const& configFile);

  Chameleon const& Value(std::string const& section, std::string const& entry) const;
  Chameleon const& Value(std::string const& section, std::string const& entry, double value);
  Chameleon const& Value(std::string const& section, std::string const& entry, std::string const& value);
};


ConfigFile::ConfigFile(std::string const& configFile) {
  std::ifstream file(configFile.c_str());

  std::string line;
  std::string name;
  std::string value;
  std::string inSection;
  int posEqual;
  while (std::getline(file,line)) {

    if (! line.length()) continue;

    if (line[0] == '#') continue;
    if (line[0] == ';') continue;

    if (line[0] == '[') {
      inSection=trim(line.substr(1,line.find(']')-1));
      continue;
    }

    posEqual=line.find('=');
    name  = trim(line.substr(0,posEqual));
    value = trim(line.substr(posEqual+1));

    content_[inSection+'/'+name]=Chameleon(value);
  }
}

Chameleon const& ConfigFile::Value(std::string const& section, std::string const& entry) const {

  std::map<std::string,Chameleon>::const_iterator ci = content_.find(section + '/' + entry);

  if (ci == content_.end()) throw "does not exist";

  return ci->second;
}

Chameleon const& ConfigFile::Value(std::string const& section, std::string const& entry, double value) {
  try {
    return Value(section, entry);
  } catch(const char *) {
    return content_.insert(std::make_pair(section+'/'+entry, Chameleon(value))).first->second;
  }
}

Chameleon const& ConfigFile::Value(std::string const& section, std::string const& entry, std::string const& value) {
  try {
    return Value(section, entry);
  } catch(const char *) {
    return content_.insert(std::make_pair(section+'/'+entry, Chameleon(value))).first->second;
  }
}


#endif
Revision:	1.1.1.1 (vendor branch)
Committed:	Fri Jun 17 13:09:26 2011 UTC (13 years, 10 months ago) by tschum
Content type:	text/plain
Branch:	tschum, MAIN
CVS Tags:	start, HEAD
Changes since 1.1:	+0 -0 lines
Log Message:	Evolved standalone RA7 limit calculation tool
#	Content
1	#ifndef CHAMELEON_H
2	#define CHAMELEON_H
3
4
5	//---chameleon class
6
7	#include <sstream>
8	#include <string>
9	#include <map>
10	#include <fstream>
11	#include <string>
12	#include <iostream>
13	#include <stdio.h>
14	#include <stdlib.h>
15	#include <math.h>
16
17	class Chameleon {
18
19	public:
20	Chameleon() {}
21	Chameleon(std::string const& value) {
22	value_=value;
23	}
24
25
26	Chameleon(const char* c) {
27	value_=c;
28	}
29
30	Chameleon(double d) {
31	std::stringstream s;
32	s<<d;
33	value_=s.str();
34	}
35
36	Chameleon(Chameleon const& other) {
37	value_=other.value_;
38	}
39
40	Chameleon& operator=(Chameleon const& other) {
41	value_=other.value_;
42	return *this;
43	}
44
45	Chameleon& operator=(double i) {
46	std::stringstream s;
47	s << i;
48	value_ = s.str();
49	return *this;
50	}
51
52	Chameleon& operator=(std::string const& s) {
53	value_=s;
54	return *this;
55	}
56
57	operator std::string() const {
58	return value_;
59	}
60
61	operator double() const {
62	return atof(value_.c_str());
63	}
64
65
66
67	private:
68	std::string value_;
69	};
70
71
72
73	//---trim function
74	std::string trim(std::string const& source, char const* delims = " \t\r\n") {
75	std::string result(source);
76	std::string::size_type index = result.find_last_not_of(delims);
77	if(index != std::string::npos)
78	result.erase(++index);
79
80	index = result.find_first_not_of(delims);
81	if(index != std::string::npos)
82	result.erase(0, index);
83	else
84	result.erase();
85	return result;
86	}
87
88	//---trim function
89
90	//---class
91	class ConfigFile {
92	std::map<std::string,Chameleon> content_;
93
94	public:
95	ConfigFile(std::string const& configFile);
96
97	Chameleon const& Value(std::string const& section, std::string const& entry) const;
98	Chameleon const& Value(std::string const& section, std::string const& entry, double value);
99	Chameleon const& Value(std::string const& section, std::string const& entry, std::string const& value);
100	};
101
102
103	ConfigFile::ConfigFile(std::string const& configFile) {
104	std::ifstream file(configFile.c_str());
105
106	std::string line;
107	std::string name;
108	std::string value;
109	std::string inSection;
110	int posEqual;
111	while (std::getline(file,line)) {
112
113	if (! line.length()) continue;
114
115	if (line[0] == '#') continue;
116	if (line[0] == ';') continue;
117
118	if (line[0] == '[') {
119	inSection=trim(line.substr(1,line.find(']')-1));
120	continue;
121	}
122
123	posEqual=line.find('=');
124	name = trim(line.substr(0,posEqual));
125	value = trim(line.substr(posEqual+1));
126
127	content_[inSection+'/'+name]=Chameleon(value);
128	}
129	}
130
131	Chameleon const& ConfigFile::Value(std::string const& section, std::string const& entry) const {
132
133	std::map<std::string,Chameleon>::const_iterator ci = content_.find(section + '/' + entry);
134
135	if (ci == content_.end()) throw "does not exist";
136
137	return ci->second;
138	}
139
140	Chameleon const& ConfigFile::Value(std::string const& section, std::string const& entry, double value) {
141	try {
142	return Value(section, entry);
143	} catch(const char *) {
144	return content_.insert(std::make_pair(section+'/'+entry, Chameleon(value))).first->second;
145	}
146	}
147
148	Chameleon const& ConfigFile::Value(std::string const& section, std::string const& entry, std::string const& value) {
149	try {
150	return Value(section, entry);
151	} catch(const char *) {
152	return content_.insert(std::make_pair(section+'/'+entry, Chameleon(value))).first->second;
153	}
154	}
155
156
157	#endif