XmlParser.hpp

Go to the documentation of this file.

/*
---------------------------------------------------------------------------
 
    This file is part of uHAL.
 
    uHAL is a hardware access library and programming framework
    originally developed for upgrades of the Level-1 trigger of the CMS
    experiment at CERN.
 
    uHAL is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    uHAL is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with uHAL.  If not, see <http://www.gnu.org/licenses/>.
 
 
      Andrew Rose, Imperial College, London
      email: awr01 <AT> imperial.ac.uk
 
      Marc Magrans de Abril, CERN
      email: marc.magrans.de.abril <AT> cern.ch
 
---------------------------------------------------------------------------
*/
 
#ifndef _uhal_XmlParser_hpp_
#define _uhal_XmlParser_hpp_
 
#include <string>
#include <deque>
#include <set>
 
#include "pugixml.hpp"
#include "uhal/log/log.hpp"
#include "uhal/log/exception.hpp"
 
namespace uhal
{
 
  namespace exception
  {
    UHAL_DEFINE_EXCEPTION_CLASS ( ContradictoryParserRule , "Exception class to handle the case where an attribute is both required and forbidden." )
    UHAL_DEFINE_EXCEPTION_CLASS ( NoActionSpecified , "Exception class to handle the case where a callback is requested without it being specified." )
    UHAL_DEFINE_EXCEPTION_CLASS ( TooManyAttributes , "Exception class to handle the case where the parser is asked to handle more than 64 attributes." )
    UHAL_DEFINE_EXCEPTION_CLASS ( UnknownAttribute , "Exception class to handle the case where an unknown attribute is parsed." )
    UHAL_DEFINE_EXCEPTION_CLASS ( AmbiguousParserRules , "Exception class to handle the case where two or more equally strict rules are passed." )
    UHAL_DEFINE_EXCEPTION_CLASS ( NoRulesPassed , "Exception class to handle the case where no rules were parsed." )
  }
 
  template < typename R >
  class Parser;
 
  template < typename R >
  class BaseFunctionObject
  {
    public:
      BaseFunctionObject();
      virtual ~BaseFunctionObject();
      virtual R operator() ( const pugi::xml_node& aNode ) = 0;
  };
 
  template < typename R , typename T >
  class FunctionObject : public BaseFunctionObject<R>
  {
    public:
      FunctionObject ( T& aT );
 
      R operator() ( const pugi::xml_node& aNode );
 
    private:
      T mT;
  };
 
  template < typename R , typename T >
  class FunctionObject<R,T*> : public BaseFunctionObject<R>
  {
    public:
      FunctionObject ( T* aT );
 
      R operator() ( const pugi::xml_node& aNode );
 
    private:
      T* mT;
  };
 
 
 
  template < typename R >
  class Rule
  {
      friend class Parser< R >;
    public:
      Rule( );
 
      virtual ~Rule();
 
      Rule<R>& require ( const std::string& aStr );
 
      Rule<R>& forbid ( const std::string& aStr );
 
      Rule<R>& optional ( const std::string& aStr );
 
      std::string description() const;
 
    private:
 
      R operator() ( const pugi::xml_node& aNode );
 
    private:
      std::set<std::string> mRequired;
      std::set<std::string> mForbidden;
      std::set<std::string> mOptional;
 
      uint32_t mRuleId;
      uint64_t mRequiredHash;
      uint64_t mForbiddenHash;
 
      BaseFunctionObject<R>* mFuncPtr;
  };
 
  template < typename R >
  class Parser
  {
    public:
      Parser();
 
      ~Parser();
 
      template < typename T >
      void addRule ( const Rule<R> & aRule , T aCallbackHandler );
 
      R operator() ( const pugi::xml_node& aNode );
 
    private:
      uint64_t mNextHash;
      std::unordered_map< std::string , uint64_t > mHashes;
      std::deque< Rule<R> > mRules;
      uint32_t mRuleCounter;
  };
 
}
 
#include "uhal/TemplateDefinitions/XmlParser.hxx"
 
#endif