---

CdbRooRoVectorCollectionR.rdl

Go to the documentation of this file.

#ifndef CDBROOREADONLY_VECTOR_COLLECTION_R_RDL
#define CDBROOREADONLY_VECTOR_COLLECTION_R_RDL

// File and Version Information:
//      $Id: CdbRooRoVectorCollectionR.rdl,v 1.5 2005/11/11 01:41:29 gapon Exp $

#include "CdbBase/CdbCPtr.hh"

#include "CdbRooReadonly/CdbRooRoPersistentCollectionR.hh"

#include <iostream>
#include <vector>
#include <string>

class TTree;

// Policy classes to fine tune an internal implementation of the vector
// collection class. The policies affect the way collection's elements
// are stored in the transient cache of the collection.

/// The policy class for plain C/C++ pointers

template< class T >
struct CdbRooRoVectorCollection_PlainPointerPolicy {

    typedef T* PointerType;

    static void delete_object( PointerType ptr ) { delete ptr; }

    static bool is_null( PointerType ptr ) { return (0 == ptr); }

    static PointerType null_object( ) { return 0; }

    static T* to_plain_pointer( PointerType ptr ) { return ptr; }

    static PointerType copy_object( const CdbCPtr<T>& theObjectPtr ) { return new T( *theObjectPtr ); }

    static PointerType copy_object( const T*          theObjectPtr ) { return new T( *theObjectPtr ); }
};

/// The policy class for CdbCPtr pointers

template< class T >
struct CdbRooRoVectorCollection_SmartPointerPolicy {

    typedef CdbCPtr<T> PointerType;

    static void delete_object( PointerType ptr ) { }

    static bool is_null( PointerType ptr ) { return ptr.isNull( ); }

    static PointerType null_object( ) { return PointerType( ); }

    static T* to_plain_pointer( PointerType ptr ) { return ptr.get( ); }

    static PointerType copy_object( const CdbCPtr<T>& theObjectPtr ) { return theObjectPtr; }

    static PointerType copy_object( const T*          theObjectPtr ) { return new T( *theObjectPtr ); }
};

/// A persistent vector-like collection of objects
/**
  * Classes eligible for this template must support the "value semantics"
  * providing the following minimal
  * interface:
  *
  *   class T {
  *   public:
  *     T();
  *     T( const T&);
  *     T& operator=(const T&);
  *     ~T();
  *   };
  *
  * The total number of elements stored in a collection of this type
  * is limited by 2**32 (unsigned 32-bit integer used as an index).
  * Therefore valid indexes of the elements lay in the following range:
  *
  *   [0..0xFFFFFFFF]
  *
  * inclusive at both sides of the range.
  *
  * THE STORAGE MODEL:
  *
  *   1. Objects of the vector are stored using the mechanism of the TTree/TBranch.
  *
  *   2. The key name of that TTree is formed by concatenating the vector collection's
  *      name and ".Elements".
  *
  *   3. The branch name is always "0".
  *
  * @see class CdbRooRoPersistentCollectionR
  */
template< class T,
          class STORAGE_POLICY = CdbRooRoVectorCollection_PlainPointerPolicy<T> >

class CdbRooRoVectorCollectionR : public CdbRooRoPersistentCollectionR {

public:

  /// The default constructor
  /**
    * It's also  needed for ROOT I/O.
    */
    CdbRooRoVectorCollectionR( );

  /// The normal constructor
  /**
    * Initialize the collection with the specified number of elements
    * constructed using the default constructor of the elements class.
    */
    CdbRooRoVectorCollectionR( unsigned int theInitialSize );

  /// The copy constructor
  /**
    * IMPORTANT NOTE:
    *
    *   Watch out for the implementation of this constructor because objects of
    *   the class can be in two states: "stored" and "transient". The same object
    *   can't be stored more than one time due to a unique naming scheme for
    *   persistent collections (and their sub-collections (and their elements)) in ROOT files.
    *   The same rule applies to copies of an object - after the master copy got stored
    *   then its copies can't be stored anymore.
    *
    *   However, for the transient cache of objects the rules are slightly different.
    *   We must duplicate the cache of objects only if the input objects ia not stored.
    *   And we don't bother about duplicating it if it's not because it can easily be
    *   populated from the persistent store.
    *
    *   And we don't care about supplementary transient context (other than the transient
    *   list of objects). That context is only used to populate the transient list
    *   from the persistent store. Copying this context accross objects can be
    *   dangerous too.
    */
    CdbRooRoVectorCollectionR( const CdbRooRoVectorCollectionR<T,STORAGE_POLICY>& theOther );

  /// Destructor

    virtual ~CdbRooRoVectorCollectionR( );

  /// The assignment operator
  /**
    * IMPORTANT NOTE:
    *
    *   See notes for the copy constructor. The same rules apply.
    */
    CdbRooRoVectorCollectionR<T,STORAGE_POLICY>& operator=( const CdbRooRoVectorCollectionR<T,STORAGE_POLICY>& theOther );

    UInt_t size( ) const { return _size; }

  /// Resize the collection
  /**
    * If the collection gets extended then added elements will be initialized using
    * the default constructor of the element's class.
    */
    virtual CdbStatus resize( UInt_t theNewSize );

    virtual CdbStatus addElement( const T& theObject );

    virtual CdbStatus addElement( const CdbCPtr<T>& theObjectPtr );

    virtual CdbStatus elementAt( UInt_t theIndex,
                                 T&     theObject ) const;

    virtual CdbStatus elementAt( UInt_t      theIndex,
                                 CdbCPtr<T>& theObjectPtr ) const;

    virtual void dump( std::ostream&      o,
                       const std::string& indent = "" ) const;

protected:

  /// Store sub-collections
  /**
    * Implement the corresponding method defined in a base class.
    *
    * @see CdbRooRoPersistentCollectionR::storeSubCollectionsAt()
    */
    virtual CdbStatus storeSubCollectionsAt( const CdbRooRoCollectionAddressR& theCollectionAddress,
                                             const CdbCPtr<TFile>&             theFilePtr,
                                             Int_t&                            theNumBytesStored );
private:

  /// Make sure that an element at specifid position is loaded into the transient cache

    CdbStatus loadElementAt( UInt_t theIndex ) const;

private:

  // Transient context
  //
  // NOTES:
  //
  //    1. The order and indexes of the vector's elements must match the ones
  //       in the TBranch. The check is done when the collection is being created.
  //
  //    2. All transient data members are used both when populating a collection
  //       and when reading from it.
  //
  //    3. In case when the collection is being populated the transient list of objects
  //       must be consistent with the persistent TBranch. Otherwise a error status is
  //       returned by the operations. The below defined "_stored" flag is used for this.
  //
  //    4. In case when the collection was fetched from a database storing is not
  //       possible. Therefore the transient cache will be lazy populated.

    mutable CdbCPtr<TFile> _tFilePtr;   //!
    mutable CdbCPtr<TTree> _tTreePtr;   //!
    mutable T*             _tObjectPtr; //!

    mutable std::vector< typename STORAGE_POLICY::PointerType > _tCachedObjects;  //! transient cache of objects

  // Persistent context

    UInt_t _size;     // A total number of elements in the collection

    ClassDefT(CdbRooRoVectorCollectionR<T>,1);
};

// Implementation of the methods

#ifndef __CINT__
#include "CdbRooReadonly/CdbRooRoVectorCollectionR.cc"
#endif
#endif /* CDBROOREADONLY_VECTOR_COLLECTION_R_RDL */

---