ChainString.h

Go to the documentation of this file.

/* emacs: this is -*- c++ -*- */
 
 
#ifndef TrigInDetAnalysisExample_ChainString_H
#define TrigInDetAnalysisExample_ChainString_H
 
 
#include <string>
#include <vector>
#include <iostream>
 
 
class ChainString : public std::string {
 
public:
 
  ChainString( const std::string& s );
 
  ChainString( const ChainString& s );
 
  ChainString& operator=(const ChainString&) = default;
 
  const std::string& head()    const { return m_head;  }
  const std::string& tail()    const { return m_tail;  }
  const std::string& roi()     const { return m_roi;   }
  const std::string& vtx()     const { return m_vtx;   }
  const std::string& element() const { return m_element; }
  const std::string& extra()   const { return m_extra; }
 
  bool        passed()  const { return m_passed; }
 
  const std::string& raw() const { return m_raw; }
  
  std::string value( const std::string& key ) const { 
    int i=findkey(key);
    if ( i>=0 ) return m_values[i];
    return "";
  }

  std::string value(size_t i) const {
    if ( i<m_values.size() ) return m_values[i];
    return "";
  }
 
  size_t vsize() const { return m_values.size(); }
  
  std::string postvalue( const std::string& key ) const { 
    if ( postcount() ) return value( key+"-post" ); 
    return "";
  }
 
  const std::vector<std::string>& values() const { return m_values; }
  const std::vector<std::string>&   keys() const { return   m_keys; }
 
  std::string         pre() const { return m_raw.substr( 0, m_raw.find(":post") ); }
  const std::string& post() const { return m_post; }
 
  size_t postcount() const { return m_postcount; }
 
  std::string subs( std::string s ) const; 
 
public:   
 
  // chop tokens off the front of a string
  static std::string chop(std::string& s1, const std::string& s2) {
    std::string::size_type pos = s1.find_first_of(s2);
    std::string s3;
    if ( pos == std::string::npos ) {
      s3 = s1;
      s1.erase(0, s1.size());
    }
    else {
      s3 = s1.substr(0, pos); 
      s1.erase(0, pos+1);
    }
    return s3;
  } 
 
protected:
 
  // chomp tokens off the end of a string
  static std::string chomp(std::string& s1, const std::string& s2) {
    //    std::string::size_type pos = s1.find(s2);
    std::string::size_type pos = s1.find_first_of(s2);
    std::string s3;
    if ( pos == std::string::npos ) return "";
 
    s3 = s1.substr(pos+1, s1.size()); 
    s1.erase(pos, s1.size());
 
    return s3;
  } 

  static char toupper( char c ) { return ( c>='a' && c<='z' ? c+'A'-'a' : c ); }

  static std::string toupper( const std::string& s ) { 
    const char* c = s.c_str();
    char tmp[512];
    char* tp = tmp;
    while (( *tp++ = toupper(*c++) ));
    return tmp;
  }

  static char tolower( char c ) { return ( c>='A' && c<='Z' ? c-'A'+'a' : c ); }

  static std::string tolower( const std::string& s ) { 
    const char* c = s.c_str();
    char tmp[512];
    char* tp = tmp;
    while (( *tp++ = tolower(*c++) ));
    return tmp;
  }
 
protected:

 
  void parse( std::string s );
 
  int findkey( const std::string& key ) const { 
    for ( int i=m_keys.size() ; i-- ; ) if ( key==m_keys[i] ) return i;
    return -1;
  }
 
private:
 
  std::string m_head;
  std::string m_tail;
  std::string m_roi;
  std::string m_vtx;
  std::string m_element;
  std::string m_extra;
 
  bool        m_passed;
 
  std::string m_raw;
 
  std::string m_post;
  size_t      m_postcount;
 
  std::vector<std::string> m_keys;
  std::vector<std::string> m_values;
 
};
 
 
 
inline  bool operator==( const ChainString& cs, const ChainString& s ) { 
   return cs.raw() == ChainString(s).raw();
}
 
inline  bool operator==( const ChainString& cs, const std::string& s ) { 
   return cs.raw() == ChainString(s).raw();
}
 
inline bool operator==( const std::string& s, const ChainString& cs ) { 
  return cs.raw() == ChainString(s).raw();
}
 
 
 
#endif // TrigInDetAnalysisExample_ChainString_H