plis.h

#ifndef _PLIS_H
#define _PLIS_H

#include <string.h>
#include <string>
#include <stdarg.h>
#include <deque>
#include <plis_regexp.h>

#define PLIS_INLINE     inline

namespace plis {
  class substring;
  class llip;
  
  class slip 
    {
      std::string pstr;
      
    public:
      slip():pstr(){}
      slip(const slip& s) : pstr(s.str()){}     
      slip(const char *s) : pstr(s){}
      slip(const char *s, int n) : pstr(s,n){}
      //    PLIS_INLINE slip(long l);
      slip(const char c) : pstr(1,c) {};
      slip(const substring& sb);
      
      slip& operator=(const char *s) {
        if (s==NULL)
          pstr = "";
        else
          pstr= s;
        return *this;
      }
      slip& operator=(const slip& s);
      slip& operator=(const substring& sb);
      
      operator const char*() const { return pstr.c_str(); }
      
      operator const std::string() const { return pstr; }
      
      const char operator[](int n) const{ return pstr[n]; }
      
      int length(void) const{ return pstr.size(); }
      
      char chop(void);
      
      void chomp(void);
      
      int index(const slip& s, int offset= 0);
      
      int rindex(const slip& s, int offset= -1);
      
      int wsplit(llip&);
      
      int strsplit(const slip&str, llip&sl);  // string split
      
      substring substr(int offset, int len= -1);
      PLIS_INLINE substring substr(const Range& r);
      
      int tr(const char *, const char *, const char *opts="");
      
      /* \brief Match a regular expression.
         \param r Regular expression
      */
      int m(Regexp& r);
      /* \brief Match a regular expression with optionts
         \param opts Optional parameters. May be one of:
         - 'i' - Case insensitive match.
      */
      int m(const char *, const char *opts=""); // the regexp match m/.../ equiv
      int m(const char *, llip& match_list, const char *opts="");
      
      /* \brief Match a regular expression.
         \param r Regular expression
         \retval match_list  The list of the sub groups found. Note that match_list[0]
         is the whole expression and $1 is placed in match_list[1], etc.
      */
      int m(Regexp&r, llip& match_list);
      int s(const char *, const char *, const char *opts="");
      
      llip split(const char *pat= "[ \\t\\n]+", int limit= -1);
      
      int operator<(const slip& s) const { return (strcmp(pstr.c_str(), s) < 0); }
      int operator>(const slip& s) const { return (strcmp(pstr.c_str(), s) > 0); }
      int operator<=(const slip& s) const { return (strcmp(pstr.c_str(), s) <= 0); }
      int operator>=(const slip& s) const { return (strcmp(pstr.c_str(), s) >= 0); }
      int operator==(const slip& s) const { return (strcmp(pstr.c_str(), s) == 0); }
      int operator==(const char *s) const { return (strcmp(pstr.c_str(), s) == 0); }
      int operator!=(const slip& s) const { return (strcmp(pstr.c_str(), s) != 0); }
      int operator!=(const char *s) const { return (strcmp(pstr.c_str(), s) != 0); }
      
      slip operator+(const slip& s) const;
      
      slip operator+(const char *s) const;
      
      slip operator+(char c) const;
      
      friend slip operator+(const char *s1, const slip& s2);
      
      friend std::istream& operator>>(std::istream&, slip&);
      
      slip& operator+=(const slip& s) { pstr.append(s.str().c_str(), s.length()); return *this;}
      
      slip& operator+=(const char *s) { pstr.append(s, strlen(s)); return *this;}
      
      slip& operator+=(char c){ pstr.append(1,c); return *this;}
      friend class substring;
      
      const std::string& str() const { return pstr; }
      
      const char *c_str() const { return pstr.c_str(); }
      
      int atoi();
      
      double atof();
      
    private:
      void insert(int pos, int len, const char *pt, int nlen);
      
    };

  class substring
    {
    public:
      int pos, len;
      slip& str;
      const char *pt;
      
      friend class slip;
      
    private:
      substring(slip& os, int p, int l) : str(os)
        {
          if(p > os.length()) p= os.length();
          if((p+l) > os.length()) l= os.length() - p;
          pos= p; len= l;
          if(p == os.length()) pt= 0; // append to end of string
          else pt= &(((const char*)os)[p]);
        }
    public:
      void operator=(const slip& s)
        {
          if(&str == &s){ // potentially overlapping
            std::string tmp((const char*)s);
            str.insert(pos, len, tmp.c_str(), tmp.length());
          }
          else str.insert(pos, len, (const char*)s, s.length());
        }
      
      void operator=(const substring& s)
        {
          if(&str == &s.str){ // potentially overlapping
            std::string tmp(s.pt, s.len);
            str.insert(pos, len, tmp.c_str(), tmp.length());
          }
          else str.insert(pos, len, s.pt, s.len);
        }
      
      void operator=(const char *s)
        {
          str.insert(pos, len, s, strlen(s));
        }
    };

  substring slip::substr(const Range& r)
    {
      return substr(r.start(), r.length());
    }
  
  class llip : public std::deque<slip>
    {
    public:
      llip(int sz=6) {};
      llip(const llip& sl) : std::deque<slip>(sl) {};
      
      slip join(const char *pat= " ");
      
      int split(const char *str, const char *pat= "[ \t\n]+", int limit= -1);
      
      int length() const { return size(); }
      int count() const { return size(); }
      void push(const slip& s) { this->push_back(s); }
      void push(const llip& sl);
      void unshift(const slip& s) { this->push_front(s); }
      void unshift(const llip& sl);
      
      operator const int() const { return size(); }
      
      slip shift() { slip s = this->front(); this->pop_front(); return s; }
      
      slip pop() { slip s = this->back(); this->pop_back(); return s; }
      
      void replace(int offset, int len, llip& l);
      llip& splice(int offset, int len);
      llip& splice(int offset);
      
      llip grep(const char *regex, const char *options = "");
    };

  slip join(llip&, const char *pat=" ");
  void push(llip& sl, const slip& s);

  slip slipprintf(const char *, ...);

  slip slipvprintf(const char *, va_list args);

  int slip_read_file(slip filename,
                     // output
                     slip& contents);
};

//std::istream& operator>>(std::istream&, plis::slip&);
//std::ostream& operator<<(std::ostream&, const plis::slip&);
//std::ostream& operator<<(std::ostream&, const plis::llip&);

#define FOREACH(var, array)\
  for (int i=0; i<array.count() && (var=array[i],1);i++) 

#endif

---

plis - Perl Like Structures