Blinker

1) /* Blinker

2)    Copyright 2011-2014 Stefan Schuermans <stefan@blinkenarea.org>

3)    Copyleft GNU public license - http://www.gnu.org/copyleft/gpl.html
4)    a blinkenarea.org project */
5) 

6) #include <math.h>

7) #include <string>
8) 
9) #include "StringParser.h"
10) 
11) namespace Blinker {
12) 
13) /**
14)  * @brief constructor
15)  * @param[in] str string to parse
16)  */
17) StringParser::StringParser(const std::string &str):
18)   m_str(str),

19)   m_it(m_str.begin())

20) {
21) }
22) 
23) /**
24)  * @brief parse fixed character
25)  * @param[in] chr character to expect
26)  * @return if expected character was found and processed
27)  */
28) bool StringParser::fixChr(char chr)
29) {
30)   if (m_it == m_str.end() || *m_it != chr)
31)     return false;
32)   ++m_it;
33)   return true;
34) }
35) 

36) /**

37)  * @brief parse one character out of a set

38)  * @param[in] set set of characters allowed
39)  * @param[out] chr character parsed
40)  * @return if a character from the set was found and processed
41)  */
42) bool StringParser::oneChrOf(const std::string &set, char &chr)
43) {
44)   if (m_it == m_str.end() || set.find(*m_it) == std::string::npos)
45)     return false;
46)   chr = *m_it;
47)   ++m_it;
48)   return true;
49) }
50) 

51) /**
52)  * @brief parse boolean value
53)  * @param[out] boolVal boolean value parsed from string
54)  * @return if parsing was successful
55)  */
56) bool StringParser::boolVal(bool &boolVal)
57) {
58)   if (m_it == m_str.end())
59)     return false;
60)   if (*m_it == '0') {
61)     boolVal = false;
62)     return true;
63)   }
64)   if (*m_it == '1') {
65)     boolVal = true;
66)     return true;
67)   }
68)   if (*m_it == 'f') {
69)     boolVal = false;
70)     const char *ptr = "false";
71)     while (m_it != m_str.end() && *ptr && *m_it == *ptr)
72)       ++m_it, ++ptr;
73)     return !*ptr;
74)   }
75)   if (*m_it == 't') {
76)     boolVal = true;
77)     const char *ptr = "true";
78)     while (m_it != m_str.end() && *ptr && *m_it == *ptr)
79)       ++m_it, ++ptr;
80)     return !*ptr;
81)   }
82)   return false;
83) }
84) 

85) /**

86)  * @brief parse unsigned number

87)  * @param[out] uint number parsed from string
88)  * @return if parsing was successful
89)  */

90) bool StringParser::uintNo(unsigned int &uint)

91) {

92)   bool ret = false;

93)   uint = 0;
94)   while (m_it != m_str.end() && *m_it >= '0' && *m_it <= '9') {
95)     uint *= 10;
96)     uint += *m_it - '0';
97)     ++m_it;

98)     ret = true;
99)   }
100)   return ret;
101) }
102) 
103) /**
104)  * @brief parse unsigned number and check minimum
105)  * @param[in] min minimum value to expect
106)  * @param[out] uint number parsed from string
107)  * @return if parsing was successful
108)  */
109) bool StringParser::uintMin(unsigned int min, unsigned int &uint)
110) {
111)   return uintNo(uint) && uint >= min;
112) }
113) 
114) /**
115)  * @brief parse signed number
116)  * @param[out] sint number parsed from string
117)  * @return if parsing was successful
118)  */
119) bool StringParser::sintNo(int &sint)
120) {

121)   int sign = 1;

122)   unsigned int uint;
123)   bool ret;
124)   sint = 0;
125)   if (m_it != m_str.end()) {
126)     switch (*m_it) {
127)       case '+':
128)         sign = 1;
129)         ++m_it;
130)         break;
131)       case '-':
132)         sign = -1;
133)         ++m_it;
134)         break;
135)     }

136)   }

137)   ret = uintNo(uint);
138)   sint = sign * uint;
139)   return ret;

140) }
141) 

142) /**
143)  * @brief parse floating point value
144)  * @param[out] fl floating point value parsed from string
145)  * @return if parsing was successful
146)  */
147) bool StringParser::floatVal(float &fl)
148) {
149)   /* parse float manually to accept floats with dot as decimal separator for
150)    * all locales */
151)   int sign = 1, exp_sign = 1;
152)   float val = 0.0f, frac_val = 0.1f, exp_val = 0.0f;
153)   bool ret = false;
154)   // sign
155)   if (m_it != m_str.end()) {
156)     switch (*m_it) {
157)       case '+':
158)         sign = 1.0f;
159)         ++m_it;
160)         break;
161)       case '-':
162)         sign = -1.0f;
163)         ++m_it;
164)         break;
165)     }
166)   }
167)   // digits before decimal pdot
168)   while (m_it != m_str.end() && *m_it >= '0' && *m_it <= '9') {
169)     val *= 10.0f;
170)     val += *m_it - '0';
171)     ++m_it;
172)     ret = true;
173)   }
174)   // decimal dot
175)   if (m_it != m_str.end() && *m_it == '.') {
176)     ++m_it;
177)     ret = true;
178)     // digits after decimal dot
179)     while (m_it != m_str.end() && *m_it >= '0' && *m_it <= '9') {
180)       val += (*m_it - '0') * frac_val;
181)       ++m_it;
182)       frac_val *= 0.1f;
183)     }
184)   }
185)   // exponent
186)   if (m_it != m_str.end() && (*m_it == 'e' || *m_it == 'E')) {
187)     ++m_it;
188)     // exponent sign
189)     if (m_it != m_str.end()) {
190)       switch (*m_it) {
191)         case '+':
192)           exp_sign = 1.0f;
193)           ++m_it;
194)           break;
195)         case '-':
196)           exp_sign = -1.0f;
197)           ++m_it;
198)           break;
199)       }
200)     }
201)     // exponent digits
202)     while (m_it != m_str.end() && *m_it >= '0' && *m_it <= '9') {
203)       exp_val *= 10.0f;
204)       exp_val += *m_it - '0';
205)       ++m_it;
206)     }
207)   }
208)   fl = sign * val * pow(10.0, exp_sign * exp_val);
209)   return ret;
210) }
211) 

212) /**
213)  * @brief parse until a delimiter is found
214)  * @param[in] delim set of delimiter characters
215)  * @param[in] empty if empty substring is okay
216)  * @param[out] str substring parsed
217)  * @return if a substring was found and processed
218)  */
219) bool StringParser::untilDelim(const std::string &delim, bool empty,
220)                               std::string &str)
221) {
222)   str.clear();

223)   while (m_it != m_str.end() && delim.find(*m_it) == std::string::npos) {

224)     str += *m_it;
225)     ++m_it;
226)   }
227)   return empty || !str.empty();
228) }
229)