flashmatch::PSet Class Reference

A nested configuration parameter set holder for flashmatch framework. More...

#include <PSet.h>

Public Member Functions
	PSet (const std::string name="", const std::string data="")
	Default constructor. More...
virtual	~PSet ()
	Default destructor. More...
	PSet (const PSet &orig)
	Copy ctor. More...
const std::string &	name () const
	name getter More...
bool	operator== (const PSet &rhs) const
	operator override More...
bool	operator!= (const PSet &rhs) const
void	rename (std::string name)
	rename method More...
void	clear ()
	clear method More...
void	add (const std::string &data)
	Set data contents. More...
void	add_value (std::string key, std::string value)
	Insert method for a simple param. More...
void	add_pset (const PSet &p)
	Insert method for a PSet rep. More...
void	add_pset (std::string key, std::string pset)
	Insert method for a PSet rep. More...
std::string	dump (size_t indent_size=0) const
	Dump into a text format. More...
std::string	data_string () const
	Dump data string. More...
template<class T >
T	get (const std::string &key) const
	Template getter. More...
template<class T >
T	get (const std::string &key, const T default_value) const
	Template getter w/ default value. More...
const PSet &	get_pset (const std::string &key) const
	None-template function to retrieve parameter set (deprecated) More...
size_t	size () const
	Returns # of parameters. More...
const std::vector< std::string >	keys () const
	Returns a vector of all parameter keys. More...
const std::vector< std::string >	value_keys () const
	Returns a vector of keys for key-value pairs. More...
const std::vector< std::string >	pset_keys () const
	Returns a vector of keys for key-PSet pairs. More...
bool	contains_value (const std::string &key) const
	Check if a specified key exists for key-value pairs. More...
bool	contains_pset (const std::string &key) const
	Check if a specified key exists for key-PSet pairs. More...
template<>
PSet	get (const std::string &key) const

Private Types
enum	KeyChar_t {   kParamDef, kBlockStart, kBlockEnd, kString,   kNone }

Private Member Functions
std::pair< PSet::KeyChar_t, size_t >	search (const std::string &txt, const size_t start) const
void	strip (std::string &str, const std::string &key)
void	rstrip (std::string &str, const std::string &key)
void	trim_space (std::string &txt)
void	no_space (std::string &txt)

Private Attributes
std::string	_name
	The name of this flashmatch::PSet. More...
std::map< std::string, std::string >	_data_value
	Key-Value pairs. More...
std::map< std::string,::flashmatch::PSet >	_data_pset
	Key-PSet pairs. More...

Detailed Description

A nested configuration parameter set holder for flashmatch framework.

Definition at line 26 of file PSet.h.

Member Enumeration Documentation

enum flashmatch::PSet::KeyChar_t

private

Enumerator
kParamDef
kBlockStart
kBlockEnd
kString
kNone

Definition at line 141 of file PSet.h.

                   {
      kParamDef,
      kBlockStart,
      kBlockEnd,
      kString,
      kNone
    };

Constructor & Destructor Documentation

flashmatch::PSet::PSet	(	const std::string	name = "",
		const std::string	data = ""
	)

Default constructor.

Definition at line 8 of file PSet.cxx.

  {
    if(name.empty()) {
      std::cerr << "Cannot make PSet with an empty name!" << std::endl;
      throw std::exception();
    }
    _name = name;
    if(!data.empty()) this->add(data);
  }

virtual flashmatch::PSet::~PSet ( )

inlinevirtual

Default destructor.

Definition at line 35 of file PSet.h.

{};

flashmatch::PSet::PSet ( const PSet &  orig )

inline

Copy ctor.

Definition at line 38 of file PSet.h.

                           : _name       ( orig._name       )
                           , _data_value ( orig._data_value )
                           , _data_pset  ( orig._data_pset  )
    {}

Member Function Documentation

void flashmatch::PSet::add

(

const std::string &

data

)

Set data contents.

Definition at line 177 of file PSet.cxx.

  {
    if(contents.size()<1) return;
    size_t index=0;
    while(contents.find(" ",index) == index)
      index +=1;
    if(index >= contents.size()) return;
    
    size_t end_index=contents.size()-1;
    while(contents.rfind(" ",end_index) == end_index)
      end_index -= 1;

    if(end_index <= index || end_index > contents.size()) return;

    std::string key,value,tmp;
    KeyChar_t last_mark=kNone;

    while(index <= end_index) {
      
      auto next_marker = this->search(contents,index);

      if(next_marker.first == kString) {

        //std::cout<<"String found in here: "<<contents.substr(index,(next_marker.second-index))<<std::endl;

        while(next_marker.second < end_index+1) {

          next_marker = this->search(contents,next_marker.second+1);

          if(next_marker.first == kString) {
            next_marker = this->search(contents,next_marker.second+1);
            break;
          }
        }
        //std::cout<<"String found in here: "<<contents.substr(index,next_marker.second-index)<<std::endl;
      }
      
      if(next_marker.second > end_index) break;
      if(next_marker.first == kNone) break;
      /*
      std::cout<<"index: "<<index<<std::endl;
      std::cout<<"marker: "<<next_marker.second<<std::endl;
      std::cout<<"type  : "<<next_marker.first<<std::endl;
      std::cout<<"last  : "<<last_mark<<std::endl;
      std::cout<<"Inspecting: "<<"\""<<contents.substr(index,(next_marker.second-index))<<"\""<<std::endl;
      */
      if(next_marker.first == kParamDef) {
        if(last_mark ==  kNone || last_mark == kBlockEnd){
          key = contents.substr(index,(next_marker.second-index));
          no_space(key);
        }
        else if(last_mark == kParamDef || last_mark == kString) {
          tmp = contents.substr(index,(next_marker.second-index));
          //std::cout<<"Inspecting: \""<<tmp<<"\"" <<std::endl;
          strip(tmp," ");
          rstrip(tmp," ");
          size_t sep_index = tmp.rfind(" ");
          if(sep_index >= tmp.size()) {
            std::cerr << "Invalid format (key:value)" << std::endl;
            throw std::exception();
          }
          value = tmp.substr(0,sep_index);
          // complete pair
          this->add_value(key,value);
          //std::cout<<"Found value: "<<value<<std::endl;         
          key = value = "";
          key = tmp.substr(sep_index+1,(tmp.size()-sep_index-1));
          no_space(key);
        }
        
      }else if(next_marker.first == kBlockEnd) {
        std::cerr << "Block end logic error!" << std::endl;
        throw std::exception();
      }

      else if(next_marker.first == kBlockStart){
        //std::cout<<"Block start!"<<std::endl;
        if(last_mark != kParamDef) {
          std::cerr << "Invalid paramter set start!" << std::endl;
          throw std::exception();
        }
        
        // fast forward till this block ends
        int start_ctr = 1;
        index = next_marker.second + 1;
        while(start_ctr && next_marker.second <= end_index) {
          
          next_marker = this->search(contents,next_marker.second+1);

          if(next_marker.first == kString) {

            while(next_marker.second < end_index+1) {

              next_marker = this->search(contents,next_marker.second+1);

              auto tmp_next_marker = this->search(contents,next_marker.second+1);

              if(next_marker.first == kString && tmp_next_marker.second != kString) {

                next_marker = tmp_next_marker;
                break;
              }

            }
            //std::cout<<"Found string :"<<contents.substr(index,next_marker.second)<<std::endl;
          }

          switch(next_marker.first){
          case kBlockStart:
            start_ctr +=1;
            break;
          case kBlockEnd:
            start_ctr -=1;
            break;
          default:
            break;
          }
        }
        if(start_ctr) {
          std::string msg;
          std::cerr << "Invalid block:\n" << contents.substr(index,next_marker.second-index) << "\n" << std::endl;
          throw std::exception();
        }
        value = contents.substr(index,next_marker.second-index);
        //std::cout<<"PSET!\n"<<value<<"\n"<<std::endl;
        // complete key/value
        this->add_pset(key,value);

        key="";
        value="";
      }
      else {
        std::cerr << "Unknown error!" << std::endl;
        throw std::exception();
      }
      
      index = next_marker.second+1;
      last_mark = next_marker.first;
    }

    if(index <= end_index) {
      
      if(!value.empty()) { std::cerr << "Non-empty value @ process-end!" << std::endl; throw std::exception(); }
      if(key.empty()) { std::cerr << "Empty key @ process-end!" << std::endl; throw std::exception(); }
      
      tmp = contents.substr(index+1,end_index-index);
      //no_space(tmp);
      trim_space(tmp);
      if(tmp.empty()) { std::cerr << "Empty value @ end!" << std::endl; throw std::exception(); }
      value = tmp;
      this->add_value(key,value);

      key = "";
      value = "";
    }
    
    if(!key.empty() || !value.empty()) {
      std::cerr << "Unpaired key:value!" << std::endl;
      throw std::exception();
    }

  }

void flashmatch::PSet::add_pset

(

const PSet &

p

)

Insert method for a PSet rep.

Definition at line 147 of file PSet.cxx.

  {
    if( _data_value.find(p.name()) != _data_value.end() ||
        _data_pset.find(p.name())  != _data_pset.end() ) {
      std::string msg;
      std::cerr << " Duplicate key: \"" << p.name() << "\"" << std::endl;
      throw std::exception();
    }    
    _data_pset.insert(std::make_pair(p.name(),p));
  }

void flashmatch::PSet::add_pset	(	std::string	key,
		std::string	pset
	)

Insert method for a PSet rep.

Definition at line 158 of file PSet.cxx.

  {
    if( _data_value.find(key) != _data_value.end() ||
        _data_pset.find(key)  != _data_pset.end() ) {
      std::string msg;
      std::cerr << " Duplicate key: \"" << key << "\"" << std::endl;
      throw std::exception(); 
    }
    no_space(key);
    if(key.empty()) {
      std::cerr << "Empty key cannot be registered!" << std::endl;
      throw std::exception();
    }
    strip(value," ");
    rstrip(value," ");
    _data_pset.emplace(key,PSet(key,value));
  }

void flashmatch::PSet::add_value	(	std::string	key,
		std::string	value
	)

Insert method for a simple param.

Definition at line 127 of file PSet.cxx.

  {
    //std::cout<<"  "<<key<<" => "<<value<<std::endl;
    if( _data_value.find(key) != _data_value.end() ||
        _data_pset.find(key)  != _data_pset.end() ) {
      std::string msg;
      std::cerr << " Duplicate key: \"" << key << "\"" << std::endl;
      throw std::exception();
    }
    no_space(key);
    if(key.empty()) {
      std::cerr << "Empty key cannot be registered!" << std::endl;
      throw std::exception();
    }
    //std::cout<<"value: @"<<value<<"@"<<std::endl;
    trim_space(value);
    _data_value[key]=value;
  }

void flashmatch::PSet::clear ( )

inline

clear method

Definition at line 76 of file PSet.h.

    { _data_value.clear(); _data_pset.clear(); }

bool flashmatch::PSet::contains_pset

(

const std::string &

key

)

const

Check if a specified key exists for key-PSet pairs.

Definition at line 49 of file PSet.cxx.

  {
    return (_data_pset.find(key) != _data_pset.end());
  }

bool flashmatch::PSet::contains_value

(

const std::string &

key

)

const

Check if a specified key exists for key-value pairs.

Definition at line 45 of file PSet.cxx.

  {
    return (_data_value.find(key) != _data_value.end());
  }

std::string flashmatch::PSet::data_string

(

)

const

Dump data string.

Definition at line 359 of file PSet.cxx.

  {

    std::string res;
    res = _name + ": {";
    for(auto const& key_value : _data_value)

      res += key_value.first + ": " + key_value.second + " ";

    for(auto const& key_value : _data_pset)

      res += key_value.second.data_string();

    res += "} ";
    return res;
  }

std::string flashmatch::PSet::dump

(

size_t

indent_size = 0

)

const

Dump into a text format.

Definition at line 340 of file PSet.cxx.

  {
    
    std::string res,in_indent,out_indent;
    for(size_t i=0; i<indent_size; ++i) out_indent += " ";
    res = out_indent + _name + " : {\n";
    in_indent = out_indent + "  ";
    for(auto const& key_value : _data_value)

      res += in_indent + key_value.first + " : " + key_value.second + "\n";

    for(auto const& key_value : _data_pset)

      res += key_value.second.dump(in_indent.size()) + "\n";

    res += out_indent + "}\n";
    return res;
  }

template<class T >

T flashmatch::PSet::get ( const std::string &  key ) const

inline

Template getter.

Definition at line 100 of file PSet.h.

                                     {
      auto iter = _data_value.find(key);
      if( iter == _data_value.end() ) {
        std::string msg;
        msg = "Key does not exist: \"" + key + "\"";
        std::cout<<dump()<<std::endl;
        std::cerr<<msg<<std::endl;
        throw std::exception();
      }
      return parser::FromString<T>((*iter).second);
    }

template<class T >

T flashmatch::PSet::get ( const std::string &  key, const T  default_value  ) const

inline

Template getter w/ default value.

Definition at line 114 of file PSet.h.

                                                            {
      auto iter = _data_value.find(key);
      if( iter == _data_value.end() )
        return default_value;
      return parser::FromString<T>((*iter).second);
    }

template<>

PSet flashmatch::PSet::get

(

const std::string &

key

)

const

const PSet & flashmatch::PSet::get_pset

(

const std::string &

key

)

const

None-template function to retrieve parameter set (deprecated)

Definition at line 376 of file PSet.cxx.

  {
    auto iter = _data_pset.find(key);
    if( iter == _data_pset.end() ) {
      std::string msg;
      std::cerr << "Key does not exist: \"" << key << "\"" << std::endl;
      throw std::exception();
    }
    return (*iter).second;

  }

const std::vector< std::string > flashmatch::PSet::keys

(

)

const

Returns a vector of all parameter keys.

Definition at line 22 of file PSet.cxx.

  {
    std::vector<std::string> res;
    res.reserve(_data_value.size() + _data_pset.size());
    for(auto const& key_value : _data_value) res.push_back(key_value.first);
    for(auto const& key_value : _data_pset ) res.push_back(key_value.first);
    return res;
  }

const std::string& flashmatch::PSet::name ( ) const

inline

name getter

Definition at line 44 of file PSet.h.

{ return _name; }

void flashmatch::PSet::no_space ( std::string &  txt )

private

Definition at line 81 of file PSet.cxx.

                                   {
    trim_space(txt);
    if(txt.find(" ") < txt.size()) {
      std::stringstream ss;
      std::cerr << " Processing: " << txt.c_str() << " ... Space not allowed!" << std::endl;
      throw std::exception();
    }
    if(txt.find("\t") < txt.size()) {
      std::cerr << "Tab not allowed!" << std::endl;
      throw std::exception();
    }
  }

bool flashmatch::PSet::operator!= ( const PSet &  rhs ) const

inline

Definition at line 69 of file PSet.h.

    { return !((*this) == rhs); }

bool flashmatch::PSet::operator== ( const PSet &  rhs ) const

inline

operator override

Definition at line 47 of file PSet.h.

    {
      if(_name != rhs.name()) return false;
      auto const v_keys = this->value_keys();
      if(v_keys.size() != rhs.value_keys().size()) return false;
      for(auto const& key : v_keys) {
        if(!rhs.contains_value(key))
          return false;
        if(this->get<std::string>(key) != rhs.get<std::string>(key))
          return false;
      }
      auto const p_keys = this->pset_keys();
      if(p_keys.size() != rhs.pset_keys().size()) return false;
      for(auto const& key : p_keys) {
        if(!rhs.contains_pset(key))
          return false;
        if(this->get_pset(key) != rhs.get_pset(key))
          return false;
      }
      return true;
    }

const std::vector< std::string > flashmatch::PSet::pset_keys

(

)

const

Returns a vector of keys for key-PSet pairs.

Definition at line 38 of file PSet.cxx.

  {
    std::vector<std::string> res;
    res.reserve(_data_pset.size());
    for(auto const& key_value : _data_pset) res.push_back(key_value.first);
    return res;
  }

void flashmatch::PSet::rename ( std::string  name )

inline

rename method

Definition at line 73 of file PSet.h.

{ _name = name; }

void flashmatch::PSet::rstrip ( std::string &  str, const std::string &  key  )

private

Definition at line 61 of file PSet.cxx.

  {
    size_t index = str.rfind(key);
    if(index >= str.size()) return;
    while(key.size() == (str.size() - index)) {
      str = str.substr(0,index);
      index = str.rfind(key);
      if(index >= str.size()) break;
    }
  }

std::pair< PSet::KeyChar_t, size_t > flashmatch::PSet::search ( const std::string &  txt, const size_t  start  ) const

private

Definition at line 94 of file PSet.cxx.

  {
    std::pair<KeyChar_t,size_t> res(kNone,size_t(-1));
    size_t index = 0;

    //
    // kParamDef
    //
    index = txt.find(":",start);
    if(index != std::string::npos && index < res.second) {
      res.first  = kParamDef;
      res.second = index;
    }
    index = txt.find("{",start);
    if(index != std::string::npos && index < res.second) {
      res.first  = kBlockStart;
      res.second = index;
    }
    index = txt.find("}",start);
    if(index != std::string::npos && index < res.second) {
      res.first  = kBlockEnd;
      res.second = index;
    }
    /*
    index = txt.find("\"",start);    
    if(index != std::string::npos && index < res.second) {
      res.first  = kString;
      res.second = index;
    }
    */
    return res;
  }

size_t flashmatch::PSet::size

(

void

)

const

Returns # of parameters.

Definition at line 19 of file PSet.cxx.

  { return (_data_value.size() + _data_pset.size()); }

void flashmatch::PSet::strip ( std::string &  str, const std::string &  key  )

private

Definition at line 54 of file PSet.cxx.

  {
    if(str.find(key) != 0) return;
    while(str.find(key) == 0)
      str = str.substr(key.size(),str.size());
  }

void flashmatch::PSet::trim_space ( std::string &  txt )

private

Definition at line 72 of file PSet.cxx.

                                     {
    strip  ( txt, " "  );
    strip  ( txt, "\t" );
    strip  ( txt, " "  );
    rstrip ( txt, " "  );
    rstrip ( txt, "\t" );
    rstrip ( txt, " "  );
  }

const std::vector< std::string > flashmatch::PSet::value_keys

(

)

const

Returns a vector of keys for key-value pairs.

Definition at line 31 of file PSet.cxx.

  {
    std::vector<std::string> res;
    res.reserve(_data_value.size());
    for(auto const& key_value : _data_value) res.push_back(key_value.first);
    return res;
  }

Member Data Documentation

std::map<std::string,::flashmatch::PSet> flashmatch::PSet::_data_pset

private

Key-PSet pairs.

Definition at line 160 of file PSet.h.

std::map<std::string,std::string> flashmatch::PSet::_data_value

private

Key-Value pairs.

Definition at line 158 of file PSet.h.

std::string flashmatch::PSet::_name

private

The name of this flashmatch::PSet.

Definition at line 156 of file PSet.h.

---

The documentation for this class was generated from the following files:

• PSet.h
• PSet.cxx