---

CdbRooRoViewR.rdl

Go to the documentation of this file.

#ifndef CDBROOREADONLY_VIEW_R_RDL
#define CDBROOREADONLY_VIEW_R_RDL

// File and Version Information:
//      $Id: CdbRooRoViewR.rdl,v 1.3 2004/12/08 17:36:47 gapon Exp $

#include "CdbBase/CdbItr.hh"

#include "CdbRooReadonly/CdbRooRoTimeR.hh"

#include <string>
#include <iostream>

class CdbRooRoConfigCollectionR;
class CdbRooRoFolderR;
class CdbRooRoConditionAtFolderR;
class CdbRooRoIdR;

/// A persistent incarnation for the concept of "view"
/**
  * See details below.
  */
class CdbRooRoViewR {

public:

  /// Default constructor
  /**
    * It's required by ROOT I/O
    */
    CdbRooRoViewR( );

  /// Normal constructor
  /**
    * WARNING: Inappropriate values of the parameters will cause the crash
    *          of the constructor to avoid creating disformed persistent
    *          data structures.
    */
    CdbRooRoViewR( const std::string&         theName,
                   UShort_t                   theId,
                   const std::string&         theDescription, 
                   const BdbTime&             theCreationTime,
                   const BdbTime&             theMinValidityTime  = BdbTime::minusInfinity,
                   const BdbTime&             theMaxValidityTime  = BdbTime::plusInfinity,
                   CdbRooRoConfigCollectionR* theDefaultConfigPtr = 0
                 );

  /// Copy constructor
  /**
    * Need a non-trivial constructor because we have we have a cyclic graph of View, Folder
    * and ConditionAtFolder objects.
    */
    CdbRooRoViewR( const CdbRooRoViewR& theOther );

  /// Destructor

    virtual ~CdbRooRoViewR( );

  /// Assignment operator
  /**
    * Need a non-trivial constructor because we have we have a cyclic graph of View, Folder
    * and ConditionAtFolder objects.
    */
    CdbRooRoViewR& operator=( const CdbRooRoViewR& theOther );

  // Accessors

    const std::string& name( ) const { return _name; }

    UShort_t id( ) const { return _id; }

    const std::string& description( ) const { return _description; }

    BdbTime created    ( ) const { return _created.getBdbTime( ); }
    BdbTime minValidity( ) const { return _minValidityTime.getBdbTime( ); }
    BdbTime maxValidity( ) const { return _maxValidityTime.getBdbTime( ); }

    const CdbRooRoConfigCollectionR* defaultConfig( ) const { return ( _useDefaultConfigPtr ? _defaultConfigPtr : 0 ); }
    CdbRooRoConfigCollectionR*       defaultConfig( )       { return ( _useDefaultConfigPtr ? _defaultConfigPtr : 0 ); }

    const CdbRooRoFolderR* rootFolder( ) const { return ( _useRootFolderPtr ? _rootFolderPtr : 0 ); }
    CdbRooRoFolderR*       rootFolder( )       { return ( _useRootFolderPtr ? _rootFolderPtr : 0 ); }

  /// Check if this view is "frozen" from any further modifications
  /**
    * If a view is in "frozen" state then it can't be modified (adding/removing
    * folders or conditions or any other relevant operations). A view gets into
    * this state immediatelly upon its creation.
    *
    * A view in the "frozen" is available to clients.
    */
    bool isFrozen( ) const { return _isFrozen; }

  /// "Freeze" the view
  /**
    * Once a view is frozen then there is no way to revert it back.
    *
    * @see CdbRooRoViewR::isFrozen()
    */
    void freeze( ) { _isFrozen = true; }

  /// "Un-freeze" the view
  /**
    * Once a view is frozen then generally there is no way to revert it back. However we
    * still need to do this sometimes.
    *
    * @see CdbRooRoViewR::isFrozen()
    */
    void warm( ) { _isFrozen = false; }

  /// Set/override default configuration at a level of a view
  /**
    * The passed pointer can be 0. The previously stored configuration
    * object (if any) will be destroyed.
    *
    * NOTE: This operation requires the view to be available for modifications
    *       (not being frozen).
    */
    CdbStatus setDefaultConfig( CdbRooRoConfigCollectionR* theConfigPtr     /**< a configuration object */
                              );

  /// Set/override configuration at a level of specified condition
  /**
    * The passed pointer can be 0. The previously stored configuration
    * object (if any) will be destroyed unless an optional 'dontDestroyConfigObject'
    * flag is set to true.
    *
    * If there is no such folder then CdbStatus::NotFound will be returned.
    * Other status values are as usual.
    *
    * NOTE: This operation requires the view to be available for modifications
    *       (not being frozen).
    */
    CdbStatus setConfig( const std::string&         thePathName,                        /**< the full path name of the condition to be modified */
                         CdbRooRoConfigCollectionR* theConfigPtr,                       /**< a configuration object */
                         bool                       dontDestroyConfigObject = false     /**< an optional flag */
                       );

  /// Create new folder
  /**
    * This operation requires the full path to a "host" folder where the specified one will
    * be placed into. The "host" folder must already be existing at a time when this method
    * is called.
    *
    * If the specified "host" folder is not found then CdbStatus::NotFound will be returned.
    * The usual error status will be returned in other cases.
    */
    CdbStatus createFolder( const std::string& thePathName,         /**< the path name to a "host" folder */
                            const std::string& theNewFolderName,    /**< the folder name at the "host" folder */
                            const std::string& theDescription,      /**< the description of the folder */
                            const BdbTime&     theCreationTime      /**< the time when the folder is supposed to be created */
                          );

  /// Create new folder (RECURSIVE)
  /**
    * This operation creates the specified folder path, including intermediate subdirectories
    * if they still do not exist.
    *
    * NOTE: The specified "description" and "creation" timestamp will be assigned to all
    *       newely created folders.
    */
    CdbStatus createFolder( const std::string& theFullPathName,     /**< the full path name of the folder to be created */
                            const std::string& theDescription,      /**< the description of the folder */
                            const BdbTime&     theCreationTime      /**< the time when the folder is supposed to be created */
                          );

  /// Create new condition
  /**
    * This operation requires the full path to a "host" folder where the specified condition will
    * be placed into. The "host" folder must already be existing at a time when this method
    * is called.
    *
    * If the specified "host" folder is not found then CdbStatus::NotFound will be returned.
    * The usual error status will be returned in other cases.
    */
    CdbStatus createCondition( const std::string&         thePathName,             /**< the path name to a "host" folder */
                               const std::string&         theNewConditionName,     /**< the condition name at the "host" folder */
                               const std::string&         theDescription,          /**< the description of the condition */
                               const BdbTime&             theCreationTime,         /**< the time when the condition is supposed to be created */
                               const CdbRooRoIdR&         theId,                   /**< the "extended" identifier of the "physical" condition */
                               CdbRooRoConfigCollectionR* theConfigPtr = 0         /**< an optional configuration object */
                             );

  /// Remove the folder
  /**
    * This operation requires the absolute path to the folder. The "root" folder
    * can never be deleted.
    *
    * If the "forceFlag" is set FALSE then only an empty folder with no other subfolders
    * or conditions in it can be removed. Otherwise both the folder itself and its contents
    * will be exterminated.
    *
    * NOTE: This operation does not affect 'physical conditions'.
    *
    * If there is no such folder then CdbStatus::NotFound will be returned.
    * Other status values are as usual.
    */
    CdbStatus removeFolder( const std::string& thePathName,         /**< the full path name of the folder to be removed */
                            bool               forceFlag = false    /**< force removal if the folder is not empty */
                          );

  /// Remove the condition
  /**
    * This operation requires the absolute path to the condition.
    *
    * If there is no such condition then CdbStatus::NotFound will be returned.
    * Other status values are as usual.
    */
    CdbStatus removeCondition( const std::string& thePathName       /**< the full path name of the condition to be removed */
                             );

  /// Find the folder
  /**
    * This operation requires the full path to the required folder. Upon successfull
    * completion it will return CdbStatus::Success. If the folder is not found
    * CdbStatus::NotFound will be returned. The error status will be returned in other cases.
    */
    CdbStatus findFolder( const std::string& thePathName,           /**< the full path name to the folder */
                          CdbRooRoFolderR*&  thePtr                 /**< the pointer to the found folder to be set up */
                        );

  /// Find the condition
  /**
    * This operation requires the full path to the required condition. Upon successfull
    * completion it will return CdbStatus::Success. If the condition is not found
    * CdbStatus::NotFound will be returned. The error status will be returned in other cases.
    */
    CdbStatus findCondition( const std::string&           thePathName,  /**< the full path name to the condition */
                             CdbRooRoConditionAtFolderR*& thePtr        /**< the poinjter to the found condition to be set up */
                           );

  /// Set up an iterator of folder names
  /**
    * This method will always return CdbStatus::Success and the only name returned
    * by the iterator would be the root folder's name.
    */
    CdbStatus folderIterator( CdbItr< const char* >& theItr     /**< the value of the iterator be set up */
                            ) const;

  /// Dump the contents of the object
  /**
    */
    void dump( std::ostream& o ) const;

private:

  // Data members

    std::string _name;

    UShort_t _id;

    std::string _description;

    CdbRooRoTimeR _created;

    CdbRooRoTimeR _minValidityTime;
    CdbRooRoTimeR _maxValidityTime;

    Bool_t                     _useDefaultConfigPtr;    // to work-around a bug in the ROOT I/O streamers
    CdbRooRoConfigCollectionR* _defaultConfigPtr;       //->

    Bool_t                     _useRootFolderPtr;       // to work-around a bug in the ROOT I/O streamers
    CdbRooRoFolderR*           _rootFolderPtr;          //->

    Bool_t _isFrozen;

    ClassDef(CdbRooRoViewR,1)
};

#endif /* CDBROOREADONLY_VIEW_R_RDL */

---