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 "uhal/log/exception.hpp"
#include "uhal/definitions.hpp"
#include "uhal/Node.hpp"

#include <boost/filesystem/path.hpp>
#include <boost/spirit/include/qi.hpp>

#include "uhal/grammars/NodeTreeClassAttributeGrammar.hpp"
#include "uhal/grammars/NodeTreeParametersGrammar.hpp"
#include "uhal/grammars/NodeTreeFirmwareInfoAttributeGrammar.hpp"

#include "pugixml.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." )

#ifdef THROW_ON_ADDRESS_SPACE_OVERLAP
    UHAL_DEFINE_EXCEPTION_CLASS ( AddressSpaceOverlap , "Exception class to handle the case where two addresses overlap." )
#endif

    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." )

    // //! Exception class to handle the case when a node has both masked and unmasked children. Uses the base uhal::exception implementation of what()
    // class BothMaskedAndUnmaskedChildren : public exception {};


    // //! Exception class to handle the case where a child node has an address which overlaps with the parent. Uses the base uhal::exception implementation of what()
    // class ChildHasAddressOverlap : public exception {};
    // //! Exception class to handle the case where a child node has an address mask which overlaps with the parent. Uses the base uhal::exception implementation of what()
    // class ChildHasAddressMaskOverlap : public exception {};
    //    //! Exception class to handle the case where a class is requested which does not exist in the class factory.
    //    UHAL_DEFINE_EXCEPTION_CLASS ( LabelUnknownToClassFactory , "Exception class to handle the case where a class is requested which does not exist in the class factory." )
  }


  class NodeTreeBuilder: private boost::noncopyable
  {

    private:
      NodeTreeBuilder ();

      virtual ~NodeTreeBuilder ();


    public:
      static NodeTreeBuilder& getInstance();

      Node* getNodeTree ( const std::string& aFilenameExpr , const boost::filesystem::path& aPath );

      void clearAddressFileCache();


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


      static bool NodePtrCompare ( Node* aNodeL, Node* aNodeR );


      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 char* mIdAttribute;
      static const char* mAddressAttribute;
      static const char* mParametersAttribute;
      static const char* mTagsAttribute;
      static const char* mDescriptionAttribute;
      static const char* mPermissionsAttribute;
      static const char* mMaskAttribute;
      static const char* mModeAttribute;
      static const char* mSizeAttribute;
      static const char* mClassAttribute;
      static const char* mModuleAttribute;
      static const char* mFirmwareInfo;

      Parser< Node* > mTopLevelNodeParser;
      Parser< Node* > mNodeParser;

      std::deque< boost::filesystem::path > mFileCallStack;

    private:
      static 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