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 unsigned number

52)  * @param[out] uint number parsed from string
53)  * @return if parsing was successful
54)  */

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

56) {

57)   bool ret = false;

58)   uint = 0;
59)   while (m_it != m_str.end() && *m_it >= '0' && *m_it <= '9') {
60)     uint *= 10;
61)     uint += *m_it - '0';
62)     ++m_it;

63)     ret = true;
64)   }
65)   return ret;
66) }
67) 
68) /**
69)  * @brief parse unsigned number and check minimum
70)  * @param[in] min minimum value to expect
71)  * @param[out] uint number parsed from string
72)  * @return if parsing was successful
73)  */
74) bool StringParser::uintMin(unsigned int min, unsigned int &uint)
75) {
76)   return uintNo(uint) && uint >= min;
77) }
78) 
79) /**
80)  * @brief parse signed number
81)  * @param[out] sint number parsed from string
82)  * @return if parsing was successful
83)  */
84) bool StringParser::sintNo(int &sint)
85) {
86)   int sign;
87)   unsigned int uint;
88)   bool ret;
89)   sint = 0;
90)   if (m_it != m_str.end()) {
91)     switch (*m_it) {
92)       case '+':
93)         sign = 1;
94)         ++m_it;
95)         break;
96)       case '-':
97)         sign = -1;
98)         ++m_it;
99)         break;
100)       default:
101)         sign = 1;
102)         break;
103)     }

104)   }

105)   ret = uintNo(uint);
106)   sint = sign * uint;
107)   return ret;

108) }
109) 

110) /**
111)  * @brief parse until a delimiter is found
112)  * @param[in] delim set of delimiter characters
113)  * @param[in] empty if empty substring is okay
114)  * @param[out] str substring parsed
115)  * @return if a substring was found and processed
116)  */
117) bool StringParser::untilDelim(const std::string &delim, bool empty,
118)                               std::string &str)
119) {
120)   str.clear();

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

122)     str += *m_it;
123)     ++m_it;
124)   }
125)   return empty || !str.empty();
126) }
127)