Parser.h

#ifndef Parser_h
#define Parser_h 1

//#include "lcio.h"
#include "IParser.h"
#include "StringParameters.h"
#include "marlin/Exceptions.h"

#include <fstream>
#include <string>
#include <iostream>

namespace marlin{

class LCTokenizer ;


typedef std::map< std::string ,  std::shared_ptr<StringParameters> > StringParametersMap;


class Parser : public IParser {
  

public:
  

  //  Parser(const std::string[] & namespaces ) ;
  //   void parse( const std::string& fileName )
  
  Parser( const std::string& fileName ) ;
  virtual ~Parser() ; 

  std::shared_ptr<StringParameters> getParameters( const std::string& sectionName ) const ;

    void setCmdLineParameters( const CommandLineParametersMap &  ){
        throw ParseException( "dynamic command line options only supported for xml steering files" ) ;
    }

  
  void parse() ;
  
  void write(const std::string& fname) const ;


protected:

  int readNextValidLine( std::string& str , std::istream& stream) ;


  mutable StringParametersMap _map{};
  StringParameters* _current ;

  std::string _fileName ;

private:
  Parser() = delete;
  Parser(const marlin::Parser&) = delete;
  Parser&  operator=(const marlin::Parser&) = delete;

};





class LCTokenizer{

  std::vector< std::string >& _tokens ;
  char _del ;
  char _last ;
  size_t _max ;
 public:

  LCTokenizer( std::vector< std::string >& tokens, char del, size_t max=-1 ) : _tokens(tokens) , _del(del), _last(del), _max(max) {
  }


  void operator()(const char& c) { 

    if( c != _del or _tokens.size() >= _max ) {

        if( _last == _del and _tokens.size() < _max ) {
          _tokens.push_back("") ; 
        }
      _tokens.back() += c ;
      result() ;
    }
    _last = c ;

  } 

  ~LCTokenizer(){
  }
  
  std::vector<std::string> & result()  { 
    
    return _tokens ; 
    
  }
};


} // end namespace marlin 
#endif