ExpressionParsing::Reader Struct Reference

#include <nimble_expression_parser.h>

Public Member Functions
	Reader (const char *lit, unsigned int len)
	Reader (const std::string &s)
	Reader (const char *lit)
	Reader (const char *start, const char *end)
	Reader (const Reader &r)
Reader	sub (const char *start, const char *end)
Reader	sub (unsigned int start, unsigned int end)
Reader	sub (const char *start, unsigned int len)
int	Next (char open, char close)
int	Prev (char open, char close)
bool	operator>> (char c)
bool	operator<< (char c)
bool	operator== (std::string &s)
bool	operator== (const char *lit)
	operator char ()
char	operator[] (unsigned int i)
std::string	MakeString ()
bool	IsEmpty ()

Public Attributes
const char *	first
unsigned int	length
unsigned int	pos = 0

Constructor & Destructor Documentation

Reader() [1/5]

ExpressionParsing::Reader::Reader ( const char * lit, unsigned int len )

inline

: first(lit), length(len) {}

Reader() [2/5]

ExpressionParsing::Reader::Reader ( const std::string & s )

inline

: Reader(s.c_str(), s.size()) {}

Reader() [3/5]

ExpressionParsing::Reader::Reader ( const char * lit )

inline

: first(lit), length(std::strlen(lit)) {}

Reader() [4/5]

ExpressionParsing::Reader::Reader ( const char * start, const char * end )

inline

: first(start), length(end - start) {}

Reader() [5/5]

ExpressionParsing::Reader::Reader ( const Reader & r )

inline

: first(r.first), length(r.length) {}

Member Function Documentation

IsEmpty()

bool ExpressionParsing::Reader::IsEmpty ( )

inline

  {
    return length == 0;
  }

MakeString()

std::string ExpressionParsing::Reader::MakeString ( )

inline

  {
    return std::string(first, length);
  }

Next()

int ExpressionParsing::Reader::Next ( char open, char close )

inline

  {
    const char* f = this->first;
    if (f[pos] == open) {
      int depth = 1;
      while (depth != 0 && pos < length) {
        char c = f[++pos];
        if (c == open)
          depth++;
        else if (c == close)
          depth--;
      }
      return depth;
    } else
      pos++;
    return 0;
  }

operator char()

ExpressionParsing::Reader::operator char ( )

inline

{ return first[pos]; }

operator<<()

bool ExpressionParsing::Reader::operator<< ( char c )

inline

  {
    pos           = length - 1;
    const char* f = first;
    while (pos > 0 && f[pos] != c) Prev('(', ')');
    if (f[pos] == c) return true;
    return false;
  }

operator==() [1/2]

bool ExpressionParsing::Reader::operator== ( const char * lit )

inline

  {
    const char* scan = first;
    const char* last = scan + length;
    while (scan < last && *lit != '\0') {
      if (*scan == *lit) {
        scan++;
        lit++;
      } else
        return false;
    }
    return scan == last && *lit == '\0';  // Ensures that all the characters matched.
  }

operator==() [2/2]

bool ExpressionParsing::Reader::operator== ( std::string & s )

inline

  {
    return operator==(s.c_str());
  }

operator>>()

bool ExpressionParsing::Reader::operator>> ( char c )

inline

  {
    pos                 = 0;
    const char* f       = first;
    int         max_pos = length - 1;
    while (pos < max_pos && f[pos] != c) Next('(', ')');
    if (f[pos] == c)
      return true;
    else
      return false;
  }

operator[]()

char ExpressionParsing::Reader::operator[] ( unsigned int i )

inline

  {
    return first[i];
  }

Prev()

int ExpressionParsing::Reader::Prev ( char open, char close )

inline

  {
    const char* f = this->first;
    if (f[pos] == close) {
      int depth = 1;
      while (depth != 0 && pos > 0) {
        char c = f[--pos];
        if (c == close)
          depth++;
        else if (c == open)
          depth--;
      }
      return depth;
    } else
      pos--;
    return 0;
  }

sub() [1/3]

Reader ExpressionParsing::Reader::sub ( const char * start, const char * end )

inline

  {
    return Reader(start, end - start);
  }

sub() [2/3]

Reader ExpressionParsing::Reader::sub ( const char * start, unsigned int len )

inline

  {
    return Reader(start, len);
  }

sub() [3/3]

Reader ExpressionParsing::Reader::sub ( unsigned int start, unsigned int end )

inline

  {
    return Reader(first + start, first + end);
  }

Member Data Documentation

first

const char* ExpressionParsing::Reader::first

length

unsigned int ExpressionParsing::Reader::length

pos

unsigned int ExpressionParsing::Reader::pos = 0

---

The documentation for this struct was generated from the following file:

• src/nimble_expression_parser.h