---

stringparser.h

Go to the documentation of this file.

#ifndef __STRINGPARSER_H__
#define __STRINGPARSER_H__

#include <string>
using std::string;
#include <strstream>
#include <vector>

#include "tristate.h"

class StringParser {
public:
  StringParser() { };
  virtual ~StringParser() { }

  typedef std::vector<string>           arglist;
  typedef std::vector<string>::iterator arglist_iterator;
  typedef std::vector<string>::iterator argptr;
  typedef std::vector<string>::const_iterator const_argptr;
  
  StringParser(const StringParser&) { } 
  virtual StringParser* clone() const { return new StringParser(*this); };


  virtual double&   parse(const string& s, double&   x) const {  basicparse(s,x);  return x;  }
  virtual int&      parse(const string& s, int&      x) const {  basicparse(s,x);  return x;  }
  virtual Tristate& parse(const string& s, Tristate& x) const {  basicparse(s,x);  return x;  }
  virtual string&   parse(const string& s, string&   x) const {  x=s;              return x;  }

  
  virtual double*&   parse(const string& s, double*&   x) const {  basicparse(s,*x); return x;  }
  virtual int*&      parse(const string& s, int*&      x) const {  basicparse(s,*x); return x;  }
  virtual Tristate*& parse(const string& s, Tristate*& x) const {  basicparse(s,*x); return x;  }
  virtual string*&   parse(const string& s, string*&   x) const {  *x=s;             return x;  }


  virtual arglist&  parse(const string& s, arglist&  x) const {
    std::istrstream ist(s.c_str(),s.length());
    x.resize(0);
    string w;
    while (ist>>w)
      x.push_back(w);
    return x;
  }

  virtual string parse(const string& s) const {  string dummy;  return parse(s,dummy);  }
  
  virtual void error(const string&) const {  }
  
private:

//template <class T>
#define BASICPARSE_DEF(T)                                               \
    static T& basicparse(const string& s, T& x)                         \
    {  std::istrstream ss(s.c_str(),s.length()); ss >> x; return x;  }

  BASICPARSE_DEF(double);
  BASICPARSE_DEF(int);
  BASICPARSE_DEF(Tristate);
};




class StringArgs {
  StringParser::arglist a; // Only used if we are constructed from string
  StringParser::argptr beg;
  StringParser::argptr end;
  
public:
  const StringParser& p; 

  StringArgs(const StringParser& parser, StringParser::argptr b, StringParser::argptr e)
    :  beg(b), end(e), p(parser)  { }
  
  StringArgs(const StringParser& parser, const string& s) : p(parser)  {
    p.parse(s,a);
    beg=a.begin();
    end=a.end();
  }

  StringArgs(const StringArgs& other)
    : a(other.a), beg(other.beg), end(other.end), p(*other.p.clone()) {
      /*
        Copy constructor is tricky -- if the other was using an internal
        container, need to construct equivalent iterators for our own
        copy.
      */ 
      if (!other.a.empty()) {
        beg=a.begin()+((StringParser::const_argptr)(other.beg)-(StringParser::const_argptr)(other.a.begin()));
        end=a.begin()+((StringParser::const_argptr)(other.end)-(StringParser::const_argptr)(other.a.begin()));
      }
    }

  bool empty() const {  return (beg==end);  }
  
  bool oneremaining() const {  return (beg+1==end);  }
  
  template<class T>
  T top(const T& default_val) const {
    if (empty())
      return default_val;
    else {
      T result;
      p.parse(*(beg), result);
      return result;
    }
  }

  void skip() {  if (!empty()) beg++;  }
  
  template<class T>
  T next(const T& default_val) {
    if (empty())
      return default_val;
    else {
      T result;
      p.parse(*(beg++), result);
      return result;
    }
  }

  template<class T>
  T* next(const T& default_val, T*& ptr) {
    if (empty())
      *ptr = default_val;
    else
      p.parse(*(beg++), ptr);
    return ptr;
  }

  template<class T>
  bool nextis(const T& test_val) {
    if (!empty()) {
      T result;
      p.parse(*beg, result);
      if (test_val == result) {
        beg++;
        return true;
      }
    }
    return false;
  }

  template<class T>
  bool lookaheadone(const T& test_val) const {
    if (empty() || (beg+1)==end)
      return false;

    T result;
    p.parse(*(beg+1), result);
    return (test_val == result);
  }

  StringArgs recursiveparser() {  return recursiveparser(next(string("")));  }

  StringArgs recursiveparser(const string s) const {  return StringArgs(p, s);  }

  string stringrep() const {
    if (beg==end) return "";
    string result = *beg;
    for (StringParser::argptr i=beg+1; i!=end; i++)
      result = result + " '" + *i + "' ";
    return result;
  }
};


#endif /* __STRINGPARSER_H__ */

---