XmlParser.hxx

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

---------------------------------------------------------------------------
*/

#include <sstream>

namespace uhal
{

  template < typename R >
  BaseFunctionObject<R>::BaseFunctionObject()
  {
  }

  template < typename R >
  BaseFunctionObject<R>::~BaseFunctionObject()
  {
  }


  template < typename R , typename T >
  FunctionObject<R,T>::FunctionObject ( T& aT ) :
    mT ( aT )
  {
  }

  template < typename R , typename T >
  R FunctionObject<R,T>::operator() ( const pugi::xml_node& aNode )
  {
    return ( mT ) ( aNode );
  }

  template < typename R , typename T >
  FunctionObject<R,T*>::FunctionObject ( T* aT ) :
    mT ( aT )
  {
  }

  template < typename R , typename T >
  R FunctionObject<R,T*>::operator() ( const pugi::xml_node& aNode )
  {
    return ( *mT ) ( aNode );
  }


  template < typename R >
  Rule<R>::Rule( ) :
    mRuleId ( 0 ),
    mRequiredHash ( 0x0000000000000000 ),
    mForbiddenHash ( 0x0000000000000000 ),
    mFuncPtr ( NULL )
  {
  }

  template < typename R >
  Rule<R>::~Rule()
  {
    if ( mFuncPtr )
    {
      delete mFuncPtr;
      mFuncPtr = NULL;
    }
  }

  template < typename R >
  Rule<R>& Rule<R>::require ( const std::string& aStr )
  {
    if ( mForbidden.find ( aStr ) != mForbidden.end() )
    {
      exception::ContradictoryParserRule lExc;
      log ( lExc , "Contradictory rule for attribute ", Quote ( aStr ) );
      throw lExc;
    }

    mRequired.insert ( aStr );
    return *this;
  }

  template < typename R >
  Rule<R>& Rule<R>::forbid ( const std::string& aStr )
  {
    if ( mRequired.find ( aStr ) != mRequired.end() )
    {
      exception::ContradictoryParserRule lExc;
      log ( lExc , "Contradictory rule for attribute ", Quote ( aStr ) );
      throw lExc;
    }

    mForbidden.insert ( aStr );
    return *this;
  }

  template < typename R >
  Rule<R>& Rule<R>::optional ( const std::string& aStr )
  {
    mOptional.insert ( aStr );
    return *this;
  }

  template < typename R >
  std::string Rule<R>::description() const
  {
    std::set<std::string>::const_iterator lIt;
    std::stringstream lStr;
    lStr << "Rule " << mRuleId ;
    lIt = mRequired.begin();

    if ( lIt != mRequired.end() )
    {
      lStr << " {Require : ";

      while ( true )
      {
        lStr << *lIt ;

        if ( ( ++lIt ) == mRequired.end() )
        {
          break;
        }

        lStr<< ", ";
      }

      lStr << "}";
    }

    lIt = mForbidden.begin();

    if ( lIt != mForbidden.end() )
    {
      lStr << " {Forbid : ";

      while ( true )
      {
        lStr << *lIt ;

        if ( ( ++lIt ) == mForbidden.end() )
        {
          break;
        }

        lStr<< ", ";
      }

      lStr << "}";
    }

    lIt = mOptional.begin();

    if ( lIt != mOptional.end() )
    {
      lStr << " {Optional : ";

      while ( true )
      {
        lStr << *lIt ;

        if ( ( ++lIt ) == mOptional.end() )
        {
          break;
        }

        lStr<< ", ";
      }

      lStr << "}";
    }

    return lStr.str();
  }

  template < typename R >
  R Rule<R>::operator() ( const pugi::xml_node& aNode )
  {
    if ( mFuncPtr )
    {
      return ( *mFuncPtr ) ( aNode );
    }
    else
    {
      exception::NoActionSpecified lExc;
      log ( lExc , "No action specified!" );
      throw lExc;
    }
  }


  template < typename R >
  Parser<R>::Parser() :
    mNextHash ( 0x0000000000000001 ),
    mRuleCounter ( 0 )
  {
    mHashes.clear();
  }

  template < typename R >
  Parser<R>::~Parser()
  {
  }



  template < typename R >
  template < typename T >
  void Parser<R>::addRule ( const Rule<R> & aRule , T aCallbackHandler )
  {
    mRules.push_back ( aRule );
    Rule<R>& lRule ( mRules.back() );

    for ( std::set<std::string>::iterator lIt = lRule.mRequired.begin() ; lIt != lRule.mRequired.end() ; ++lIt )
    {
      boost::unordered_map< std::string , uint64_t >::iterator lIt2 ( mHashes.find ( *lIt ) );

      if ( lIt2 == mHashes.end() )
      {
        if ( mNextHash == 0x0000000000000000 )
        {
          exception::TooManyAttributes lExc;
          log ( lExc , "Too many attributes" );
          throw lExc;
        }

        lRule.mRequiredHash |= mNextHash;
        mHashes.insert ( std::make_pair ( *lIt , mNextHash ) );
        mNextHash <<= 1;
      }
      else
      {
        lRule.mRequiredHash |= lIt2->second;
      }
    }

    for ( std::set<std::string>::iterator lIt = lRule.mForbidden.begin() ; lIt != lRule.mForbidden.end() ; ++lIt )
    {
      boost::unordered_map< std::string , uint64_t >::iterator lIt2 ( mHashes.find ( *lIt ) );

      if ( lIt2 == mHashes.end() )
      {
        if ( mNextHash == 0x0000000000000000 )
        {
          exception::TooManyAttributes lExc;
          log ( lExc , "Too many attributes" );
          throw lExc;
        }

        lRule.mForbiddenHash |= mNextHash;
        mHashes.insert ( std::make_pair ( *lIt , mNextHash ) );
        mNextHash <<= 1;
      }
      else
      {
        lRule.mForbiddenHash |= lIt2->second;
      }
    }

    for ( std::set<std::string>::iterator lIt = lRule.mOptional.begin() ; lIt != lRule.mOptional.end() ; ++lIt )
    {
      boost::unordered_map< std::string , uint64_t >::iterator lIt2 ( mHashes.find ( *lIt ) );

      if ( lIt2 == mHashes.end() )
      {
        if ( mNextHash == 0x0000000000000000 )
        {
          exception::TooManyAttributes lExc;
          log ( lExc , "Too many attributes" );
          throw lExc;
        }

        mHashes.insert ( std::make_pair ( *lIt , mNextHash ) );
        mNextHash <<= 1;
      }
    }

    lRule.mRuleId = ++mRuleCounter;
    lRule.mFuncPtr = new FunctionObject<R,T> ( aCallbackHandler );
  }


  template < typename R >
  R Parser<R>::operator() ( const pugi::xml_node& aNode )
  {
    uint64_t lHash ( 0x0000000000000000 );

    for ( pugi::xml_attribute lAttr = aNode.first_attribute(); lAttr; lAttr = lAttr.next_attribute() )
    {
      boost::unordered_map< std::string , uint64_t >::iterator lIt2 ( mHashes.find ( lAttr.name() ) );

      if ( lIt2 == mHashes.end() )
      {
        exception::UnknownAttribute lExc;
        log ( lExc , "Parser failed because of unknown attribute ", Quote ( lAttr.name() ) );
        throw lExc;
      }

      lHash |= lIt2->second;
    }

    std::deque< Rule<R>* > lPassed;
    std::deque< Rule<R>* > lFailedRequired;
    std::deque< Rule<R>* > lFailedForbidden;
    int i ( 0 );

    for ( typename std::deque< Rule<R> >::iterator lIt = mRules.begin() ; lIt != mRules.end() ; ++lIt, ++i )
    {
      if ( lIt->mForbiddenHash & lHash )
      {
        lFailedForbidden.push_back ( & ( *lIt ) );
      }
      else if ( lIt->mRequiredHash & ~lHash )
      {
        lFailedRequired.push_back ( & ( *lIt ) );
        continue;
      }
      else
      {
        lPassed.push_back ( & ( *lIt ) );
      }
    }

    if ( lPassed.size() == 1 )
    {
      return ( *lPassed.front() ) ( aNode );
    }

    if ( lPassed.size() > 1 )
    {
      log ( Warning() , "Ambiguity! " , Integer ( lPassed.size() ) ," rules passed. Attempting to find the rule with the most stringent requirements." );
      Rule<R>* lMostStringent ( NULL );
      uint32_t lCounter ( 0 );

      for ( typename std::deque< Rule<R>* >::iterator lIt = lPassed.begin(); lIt != lPassed.end(); ++lIt )
      {
        if ( lCounter < ( **lIt ).mRequired.size() )
        {
          lMostStringent = ( *lIt );
          lCounter = ( **lIt ).mRequired.size();
        }
        else if ( lCounter == ( **lIt ).mRequired.size() )
        {
          lMostStringent = NULL;
        }
      }

      if ( !lMostStringent )
      {
        exception::AmbiguousParserRules lExc;
        log ( lExc , "Ambiguity remains! Multiple rules passed " , Integer ( lCounter ) , " requirements." );
        throw lExc;
      }

      log ( Warning() , "In ambiguous case, selected " , lMostStringent->description() );
      return ( *lMostStringent ) ( aNode );
    }

    std::stringstream lStr;

    for ( pugi::xml_attribute lAttr = aNode.first_attribute(); lAttr; lAttr = lAttr.next_attribute() )
    {
      lStr << lAttr.name() << "=\"" << lAttr.value() << "\", ";
    }

    std::string lString ( lStr.str() );
    lString.resize ( lString.size() - 2 );
    exception::NoRulesPassed lExc;
    log ( lExc , "Node with attributes : " , lString , " failed all parser rules because : " );

    for ( typename std::deque< Rule<R>* >::iterator lIt = lFailedRequired.begin() ; lIt != lFailedRequired.end(); ++lIt )
    {
      std::stringstream lStr;
      uint64_t lTemp ( ( **lIt ).mRequiredHash & ~lHash );

      for ( boost::unordered_map< std::string , uint64_t >::iterator lIt2 = mHashes.begin() ; lIt2 != mHashes.end() ; ++lIt2 )
      {
        if ( ( lIt2->second ) & lTemp )
        {
          lStr << "\"" << lIt2->first << "\", ";
        }
      }

      std::string lString ( lStr.str() );
      lString.resize ( lString.size() - 2 );
      log ( lExc , "Rule " ,  Integer ( ( **lIt ).mRuleId ) , " requires attributes : " , lString );
    }

    for ( typename std::deque< Rule<R>* >::iterator lIt = lFailedForbidden.begin() ; lIt != lFailedForbidden.end(); ++lIt )
    {
      std::stringstream lStr;
      uint64_t lTemp ( ( **lIt ).mForbiddenHash & lHash );

      for ( boost::unordered_map< std::string , uint64_t >::iterator lIt2 = mHashes.begin() ; lIt2 != mHashes.end() ; ++lIt2 )
      {
        if ( ( lIt2->second ) & lTemp )
        {
          lStr << "\"" << lIt2->first << "\", ";
        }
      }

      std::string lString ( lStr.str() );
      lString.resize ( lString.size() - 2 );
      log ( lExc , "Rule " ,  Integer ( ( **lIt ).mRuleId ) , " forbids attributes : " , lString );
    }

    throw lExc;
  }

}