Blinker

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

18)   m_it(m_str.begin())

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

35) /**

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

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

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

84) /**

85)  * @brief parse unsigned number

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

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

90) {

91)   bool ret = false;

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

97)     ret = true;
98)   }
99)   return ret;
100) }
101) 
102) /**
103)  * @brief parse unsigned number and check minimum
104)  * @param[in] min minimum value to expect
105)  * @param[out] uint number parsed from string
106)  * @return if parsing was successful
107)  */
108) bool StringParser::uintMin(unsigned int min, unsigned int &uint)
109) {
110)   return uintNo(uint) && uint >= min;
111) }
112) 
113) /**
114)  * @brief parse signed number
115)  * @param[out] sint number parsed from string
116)  * @return if parsing was successful
117)  */
118) bool StringParser::sintNo(int &sint)
119) {
120)   int sign;
121)   unsigned int uint;
122)   bool ret;
123)   sint = 0;
124)   if (m_it != m_str.end()) {
125)     switch (*m_it) {
126)       case '+':
127)         sign = 1;
128)         ++m_it;
129)         break;
130)       case '-':
131)         sign = -1;
132)         ++m_it;
133)         break;
134)       default:
135)         sign = 1;
136)         break;
137)     }

138)   }

139)   ret = uintNo(uint);
140)   sint = sign * uint;
141)   return ret;

142) }
143) 

144) /**
145)  * @brief parse until a delimiter is found
146)  * @param[in] delim set of delimiter characters
147)  * @param[in] empty if empty substring is okay
148)  * @param[out] str substring parsed
149)  * @return if a substring was found and processed
150)  */
151) bool StringParser::untilDelim(const std::string &delim, bool empty,
152)                               std::string &str)
153) {
154)   str.clear();

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

156)     str += *m_it;
157)     ++m_it;
158)   }
159)   return empty || !str.empty();
160) }
161)