NodeTreeBuilder.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_NodeTreeBuilder_hpp_
#define _uhal_NodeTreeBuilder_hpp_
 
 
#include <boost/filesystem/path.hpp>
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
#include <boost/spirit/include/qi.hpp>
 
#include "pugixml.hpp"
 
#include "uhal/definitions.hpp"
#include "uhal/grammars/NodeTreeClassAttributeGrammar.hpp"
#include "uhal/grammars/NodeTreeParametersGrammar.hpp"
#include "uhal/grammars/NodeTreeFirmwareInfoAttributeGrammar.hpp"
#include "uhal/log/exception.hpp"
#include "uhal/Node.hpp"
#include "uhal/XmlParser.hpp"
 
 
namespace uhal
{
  namespace exception
  {
    UHAL_DEFINE_EXCEPTION_CLASS ( NodeMustHaveUID , "Exception class to handle the case where creation of a node was attempted without it having a UID." )
    UHAL_DEFINE_EXCEPTION_CLASS ( IncorrectAddressTableFileCount , "Exception class to handle the case where too many or two few address files are specified." )
    UHAL_DEFINE_EXCEPTION_CLASS ( FailedToOpenAddressTableFile , "Exception class to handle the case where the address file failed to open." )
    UHAL_DEFINE_EXCEPTION_CLASS ( IncrementalNodeRequiresSizeAttribute , "Exception class to handle the case where an incremental node is specified without a size attribute." )
    UHAL_DEFINE_EXCEPTION_CLASS ( ArraySizeExceedsRegisterBound , "Exception class to handle the case where a memory block has a size which would exceed the available register space." )
 
    UHAL_DEFINE_EXCEPTION_CLASS ( BlockAccessNodeCannotHaveChild , "Exception class to handle the case when someone tries to give a block access node a child." )
 
    UHAL_DEFINE_EXCEPTION_CLASS ( MaskedNodeCannotHaveChild , "Exception class to handle the case when someone tries to give a bit-masked node a child." )
  }
 
 
  class NodeTreeBuilder: private boost::noncopyable
  {
    private:
      NodeTreeBuilder ();
 
    public:
      virtual ~NodeTreeBuilder ();
 
      static NodeTreeBuilder& getInstance();
 
      Node* getNodeTree ( const std::string& aFilenameExpr , const boost::filesystem::path& aPath );
 
      void clearAddressFileCache();
 
      Node* build(const pugi::xml_node& aNode, const boost::filesystem::path& aAddressFilePath);
 
    private:
      void CallBack ( const std::string& aProtocol , const boost::filesystem::path& aPath , std::vector<uint8_t>& aFile , std::vector< const Node* >& aAddressTable );
 
      void calculateHierarchicalAddresses ( Node* aNode , const uint32_t& aAddr );
 
      void checkForAddressCollisions ( Node* aNode , const boost::filesystem::path& aPath );
 
      Node* plainNodeCreator ( const bool& aRequireId , const pugi::xml_node& aXmlNode );
      //       Node* classNodeCreator ( const bool& aRequireId , const pugi::xml_node& aXmlNode );
      Node* moduleNodeCreator ( const bool& aRequireId , const pugi::xml_node& aXmlNode );
      Node* bitmaskNodeCreator ( const bool& aRequireId , const pugi::xml_node& aXmlNode );
 
      void setUid ( const bool& aRequireId , const pugi::xml_node& aXmlNode , Node* aNode );
      void setClassName ( const pugi::xml_node& aXmlNode , Node* aNode );
      void setPars ( const pugi::xml_node& aXmlNode , Node* aNode );
      void setAddr ( const pugi::xml_node& aXmlNode , Node* aNode );
      void setTags ( const pugi::xml_node& aXmlNode , Node* aNode );
      void setDescription ( const pugi::xml_node& aXmlNode , Node* aNode );
      void setModule ( const pugi::xml_node& aXmlNode , Node* aNode );
      void setPermissions ( const pugi::xml_node& aXmlNode , Node* aNode );
      void setMask ( const pugi::xml_node& aXmlNode , Node* aNode );
      void setModeAndSize ( const pugi::xml_node& aXmlNode , Node* aNode );
      void setFirmwareInfo ( const pugi::xml_node& aXmlNode , Node* aNode );
      void addChildren ( const pugi::xml_node& aXmlNode , Node* aNode );
 
      static const std::string mIdAttribute;
      static const std::string mAddressAttribute;
      static const std::string mParametersAttribute;
      static const std::string mTagsAttribute;
      static const std::string mDescriptionAttribute;
      static const std::string mPermissionsAttribute;
      static const std::string mMaskAttribute;
      static const std::string mModeAttribute;
      static const std::string mSizeAttribute;
      static const std::string mClassAttribute;
      static const std::string mModuleAttribute;
      static const std::string mFirmwareInfo;
 
      Parser< Node* > mTopLevelNodeParser;
      Parser< Node* > mNodeParser;
 
      std::deque< boost::filesystem::path > mFileCallStack;
 
    private:
      static boost::shared_ptr<NodeTreeBuilder> mInstance;
 
      boost::unordered_map< std::string , const Node* > mNodes;
 
      static const struct permissions_lut : boost::spirit::qi::symbols<char, defs::NodePermission>
      {
        permissions_lut();
      } mPermissionsLut; 
 
 
      static const struct mode_lut : boost::spirit::qi::symbols<char, defs::BlockReadWriteMode>
      {
        mode_lut();
      } mModeLut; 
 
      grammars::NodeTreeClassAttributeGrammar mNodeTreeClassAttributeGrammar;
      grammars::NodeTreeParametersGrammar mNodeTreeParametersGrammar;
      grammars::NodeTreeFirmwareinfoAttributeGrammar mNodeTreeFirmwareInfoAttributeGrammar;
 
  };
 
}
 
#endif