---

CdbRooRoNameIdCollectionR.rdl

Go to the documentation of this file.

#ifndef CDBROOREADONLY_NAME_ID_COLLECTION_R_RDL
#define CDBROOREADONLY_NAME_ID_COLLECTION_R_RDL

// File and Version Information:
//      $Id: CdbRooRoNameIdCollectionR.rdl,v 1.9 2005/11/11 01:41:27 gapon Exp $

#include "CdbBase/CdbCPtr.hh"
#include "CdbBase/CdbItr.hh"

#include "CdbRooReadonly/CdbRooRoPersistentCollectionR.hh"
#include "CdbRooReadonly/CdbRooRoVectorCollectionR.hh"

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

/// A persistent collection of 'named' and 'id'-ed objects
/**
  * Classes eligible for this template must have the following minimal
  * interface:
  *
  *   class T {
  *   public:
  *     T();
  *     T( const T&);
  *     std::string name() const;
  *     UShort_t id() const;
  *   };
  *
  * NOTE: The total number of elements stored in a collection of this type
  *       is limited by 64K. Therefore valid indexes of the elements lay in
  *       the following range: [0..0xFFFF], inclusive at both sides of the range.
  */
template< class T >
class CdbRooRoNameIdCollectionR : public CdbRooRoPersistentCollectionR {

private:

  /// The assignment operator (NOT IMPLEMENTED)

    CdbRooRoNameIdCollectionR<T>& operator=( const CdbRooRoNameIdCollectionR<T>& theOther );

public:

  /// The normal and the default constructor
  /**
    * It's also  needed for ROOT I/O.
    */
    CdbRooRoNameIdCollectionR( );

  /// 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.
    *
    *   The cache of objects gets always duplicated since it's using counted smart pointers.
    *
    *   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.
    */
    CdbRooRoNameIdCollectionR( const CdbRooRoNameIdCollectionR<T>& theOther );

  /// Destructor

    virtual ~CdbRooRoNameIdCollectionR( );

    UInt_t size( ) const { return _indexById.size( ); }

    virtual CdbStatus add( const T& theObject );

    virtual CdbStatus find( UShort_t theId,
                            T&       theObject ) const;

    virtual CdbStatus find( UShort_t      theId,
                            CdbCPtr< T >& theObjectPtr ) const;

    virtual CdbStatus find( const std::string& theName,
                            T&                 theObject ) const;

    virtual CdbStatus find( const std::string& theName,
                            CdbCPtr< T >&      theObjectPtr ) const;

  /// Return a sorted collection of identifiers

    void identifiers( std::vector<UShort_t>& theCollection ) const;

  /// Return a sorted collection of names

    void names( std::vector<std::string>& theCollection ) const;

  /// Return an iterator producing a sorted sequence of identifiers

    CdbItr< UShort_t > iterator_identifiers( ) const;

  /// Return an iterator producing a sorted sequence of names

    CdbItr< std::string > iterator_names( ) 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:

  // The vector collection of objects

    CdbRooRoVectorCollectionR<T> _objects;

  // This data structure maps identifiers of stored objects onto indexes of these objects
  // in the above defined vector collection.

    std::map<UShort_t,UInt_t> _indexById;

  // And so for the names...

    std::map<std::string,UInt_t> _indexByName;

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

// Implementation of the methods

#ifndef __CINT__
#include "CdbRooReadonly/CdbRooRoNameIdCollectionR.cc"
#endif
#endif /* CDBROOREADONLY_NAME_ID_COLLECTION_R_RDL */

---