---

FlagXML.h

Go to the documentation of this file.

// Author : Samvel Khalatian (samvel at fnal dot gov)
// Created: 06/01/06
// License: GPL

#ifndef FLAG_XML_H
#define FLAG_XML_H

#include <list>
#include <map>

#include <boost/serialization/nvp.hpp>
#include <boost/serialization/string.hpp>
#include <boost/serialization/list.hpp>

#include "CalibTracker/SiStripRunSummary/interface/ClassIDBase.h"
#include "CalibTracker/SiStripRunSummary/interface/ClassID.h"
#include "CalibTracker/SiStripRunSummary/interface/Flag.h"

// Declare class to save compilation time: used for conversion of flags
// Txt -> XML
class FlagTxt;

class FlagXML: public Flag {
  public:
    typedef std::list<FlagXML *> LChildren;

    FlagXML(): Flag() { poParentFlag_ = 0; }
    virtual ~FlagXML();

    template<class T> FlagXML *createChild();

    template<class T> FlagXML *getChild   () const;

    template<class T> int getChildren( LChildren &roLChildren) const;

    virtual bool setState( const State &reSTATE);

  protected:
    FlagXML( const FlagXML &roFLAGXML);

    FlagXML( const FlagTxt &roFLAGTXT);

    inline virtual 
      int isChildValid( const FlagXML * /* poCHILD_CANDIDATE */) const {

      // No children are allowed by default
      return 0;
    }

  private:
    friend class FlagTxt;

    typedef ClassIDBase::ID FlagID; 
    typedef std::multimap<FlagID,FlagXML *> MChildFlags;

    FlagXML &operator =( const FlagXML &roFLAGXML);

    void updateState( const State &reCHILD_STATE);

    void addChild( FlagXML *poSubFlag);

    friend class boost::serialization::access;

    template<class Archive>
      void save( Archive &roArchive, const unsigned int &rnVersion) const;

    template<class Archive>
      void load( Archive &roArchive, const unsigned int &rnVersion);

    BOOST_SERIALIZATION_SPLIT_MEMBER()
    FlagXML     *poParentFlag_;
    MChildFlags  oMChildFlags_;
};

// --[ TEMPLATES IMPLEMENTATION ]----------------------------------------------
//                                                  --[ PUBLIC ]--
template<class T>
  FlagXML *FlagXML::createChild() {
    FlagXML *poResult = 0;
    
    try {
      // Create object of requested class: may throw exception
      FlagXML *poFlag = new T();

      // Get number of allowed children
      int nChildFlags = isChildValid( poFlag);

      FlagID nID = ClassID<T>::get();

      switch( nChildFlags) {
        case 0:
          // No child flags allowed
          delete poFlag;
          break;
        case -1:
          // No limit on child flags
          {
            // Parent will be set by addChild(...)
            addChild( poFlag);

            // Update parent state: child may be put into ERROR state by 
            // default (this is specified in Flag class). Unfortunately
            // parent won't be updated
            updateState( poFlag->getState());

            poResult = poFlag;
          }
          break;
        default:
          // All other cases
          {
            if( 0 < nChildFlags) {
              // Check if Flag already exists
              std::pair<MChildFlags::const_iterator, 
                        MChildFlags::const_iterator> oFoundChildren = 
                oMChildFlags_.equal_range( nID);

              if( nChildFlags > std::distance( oFoundChildren.first,
                                               oFoundChildren.second)) {

                // Parent will be set by addChild(...)
                addChild( poFlag);

                // Update parent state: child may be put into ERROR state by 
                // default (this is specified in Flag class). Unfortunately
                // parent won't be updated
                updateState( poFlag->getState());

                poResult = poFlag;
              } else {
                // No more child tags are allowed
                delete poFlag;
              }
            } else {
              // Unsupported value of child flags returned
              delete poFlag;
            }// End check if nChildFlags is positive
          }
          break;
      } // End switch( nChildFlags)
    } catch(...) {
      // Ups, trying to create child of Flag that is not inherited from
      // given class :[
    }

    return poResult;
  }

template<class T>
  FlagXML *FlagXML::getChild() const {
    // Get Class ID
    FlagID nID = ClassID<T>::get();

    // Find appropriate child
    std::pair<MChildFlags::const_iterator, MChildFlags::const_iterator>
      oFoundChildren = oMChildFlags_.equal_range( nID);

    // Return found child or invalid pointer in case child can not be found
    FlagXML *poChild = 0;
    if( 1 == std::distance( oFoundChildren.first, oFoundChildren.second)) {
      // One child was found: copy pointer
      poChild = oFoundChildren.first->second;
    }

    return poChild;
  }

template<class T>
  int FlagXML::getChildren( LChildren &roLChildren) const {
    // Get Class ID
    FlagID nID = ClassID<T>::get();

    // Find appropriate children
    std::pair<MChildFlags::const_iterator, MChildFlags::const_iterator>
      oFoundChildren = oMChildFlags_.equal_range( nID);

    // Return found child or invalid pointer in case child can not be found
    // Return list of found children or empty one if children can not be
    // found
    roLChildren.clear();
    if( 0 < std::distance( oFoundChildren.first, oFoundChildren.second)) {
      // A number of children was found: copy them into a list and return it
      while( oFoundChildren.first != oFoundChildren.second) {
        roLChildren.push_back( ( oFoundChildren.first++)->second);
      }
    } // End check if any children are found

    return roLChildren.size();
  }

//                                                  --[ PRIVATE ]--
template<class Archive>
  void FlagXML::save( Archive &roArchive, const unsigned int &rnVersion) const {
    roArchive & BOOST_SERIALIZATION_NVP( eState_);
    roArchive & BOOST_SERIALIZATION_NVP( oComment_);

    // Copy Child Flags into list: we can not save map since IDs of classes
    // are runtime dependent. Solution: save pure list of child flags. And
    // Recreate map on reading the list from archive.
    LChildren oLChildren;
    for( MChildFlags::const_iterator oIter = oMChildFlags_.begin();
         oIter != oMChildFlags_.end();
         ++oIter) {

      oLChildren.push_back( oIter->second);
    }

    // Save Child Flags
    roArchive & BOOST_SERIALIZATION_NVP( oLChildren);
  }

template<class Archive>
  void FlagXML::load( Archive &roArchive, const unsigned int &rnVersion) {
    roArchive & BOOST_SERIALIZATION_NVP( eState_);
    roArchive & BOOST_SERIALIZATION_NVP( oComment_);

    // Read Child Flags: regular list will be extracted.
    LChildren oLChildren;
    roArchive & BOOST_SERIALIZATION_NVP( oLChildren);

    // Reconstruct map of child flags since IDs of classes are runtime
    // dependent.
    for( LChildren::const_iterator oIter = oLChildren.begin();
         oIter != oLChildren.end();
         ++oIter) {

      // Parent will be set by addChild(...)
      addChild( *oIter);
    }
  }
#endif

---