XMLParser.h

#ifndef XMLParser_h
#define XMLParser_h 1

#include "IParser.h"
#include "StringParameters.h"
#include "marlin/tinyxml.h"

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

class TiXmlNode ;
class TiXmlDocument ;

namespace marlin{

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

  class XMLParser : public IParser {
  

  public:


    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 ; 
    
      }
    };
  

    XMLParser( const std::string& fileName, bool forCCheck=false ) ;
    virtual ~XMLParser() ; 

    void setCmdLineParameters( const CommandLineParametersMap & cmdlineparams ){
        _cmdlineparams = cmdlineparams ;
    }

    void parse() ;

    std::shared_ptr<StringParameters> getParameters( const std::string& sectionName ) const ;
    
    void write(const std::string &filen) const ;
  protected:

    void parametersFromNode(TiXmlNode* section, std::map<std::string, std::string>& constants, std::pair<unsigned,unsigned>* typeCount=0) ;

    const char* getAttribute( TiXmlNode* node , const std::string& name ) ;

    void replacegroups(TiXmlNode* section) ;
    
    TiXmlNode* findElement( TiXmlNode* node , const std::string& type, 
                            const std::string& attribute, const std::string& value ) ;


    void processconditions( TiXmlNode* current , const std::string& conditions ) ;

    void processIncludeElements( TiXmlElement* element , const std::map<std::string, std::string>& constants );
    
    void processIncludeElement( TiXmlElement* element , const std::map<std::string, std::string>& constants , TiXmlDocument &document);

    void processConstants( TiXmlNode* node , std::map<std::string, std::string>& constants ) ;
    void processConstant( TiXmlElement* element , std::map<std::string, std::string>& constants ) ;
    
    std::string &performConstantReplacement( std::string& value, const std::map<std::string, std::string>& constants ) ;
    
    void checkForNestedIncludes( const TiXmlNode *node );

    mutable StringParametersMap _map{};
    StringParameters* _current ;
    std::unique_ptr<TiXmlDocument> _doc{};

    std::string _fileName ;

  private:
    XMLParser() = delete;
    XMLParser(const marlin::XMLParser&) = delete;
    XMLParser& operator=(const marlin::XMLParser&) = delete;
    bool _forCCheck; //boolean variable set to true if parser is used for consistency checking

    CommandLineParametersMap _cmdlineparams{};

  };

} // end namespace marlin 
#endif