Event/GeneratorObject/include/DataModel/ElementLink.h

Go to the documentation of this file.

#ifndef DATAMODEL_ELEMENTLINK_H
#define DATAMODEL_ELEMENTLINK_H
 
#ifndef DATAMODEL_TOOLS_GENERATEINDEXINGPOLICY_H
#  include "DataModel/tools/GenerateIndexingPolicy.h"
#endif
 
#ifndef DATAMODEL_TOOLS_DATAPROXYSTORAGE_H
#  include "DataModel/tools/DataProxyStorage.h"
#endif
 
#ifndef __EXCEPTION__
#  include <exception>
#endif
 
/** @class ElementLink
 * @brief a persistable pointer to an element of a STORABLE (data object)
 *
 * @param STORABLE        host object type (e,g. vector<Elem>, NOT Elem),
 * @param StoragePolicy   STORABLE management policy (defaults to DataProxyStorage)
 * @param IndexingPolicy  policy to find the element in the host STORABLE \n
 * IndexingPolicy is generated automatically for STL sequences
 * (e.g. vector, DataList etc). For other types of containers
 * (e.g. maps), the container author must define the container type
 * using the macros in tools/DeclareIndexingPolicies.h \n
 * Advanced developers may have to define an ad-hoc indexing policy
 * (e.g. GenParticleIndexing in GeneratorObjects/McEventIndexingPolicy.h)
 *
 * @author ATLAS Collaboration
 * $Id: ElementLink.h,v 1.3 2003/06/04 16:01:22 calaf Exp $
 **/
 
class IProxyDict;
 
template <typename STORABLE, class StoragePolicy = DataProxyStorage<STORABLE>,
          class IndexingPolicy = typename SG::GenerateIndexingPolicy<STORABLE>::type>
class ElementLink : public StoragePolicy, public IndexingPolicy {
private:
  typedef typename IndexingPolicy::pointer pointer;
 
public:
  //  typedef typename StoragePolicy::ID_type ID_type;
  typedef typename std::string ID_type;
  //  typedef typename StoragePolicy::const_reference BaseConstReference;
  typedef const STORABLE&                                BaseConstReference;
  typedef typename IndexingPolicy::index_type            index_type;
  typedef typename IndexingPolicy::ElementParameter      ElementParameter;
  typedef typename IndexingPolicy::ElementConstReference ElementConstReference;
  typedef typename IndexingPolicy::ElementConstPointer   ElementConstPointer;
  typedef typename IndexingPolicy::ElementPointer        ElementPointer;
 
  // CONSTRUCTORS
  /// default
  ElementLink( IProxyDict* sg = StoragePolicy::defaultDataSource() )
      : StoragePolicy( sg ), IndexingPolicy(), m_element( 0 ) {}
 
  /// o(1) version: provide storable key and element index
  ElementLink( const ID_type& dataID, index_type elemID,
               IProxyDict* sg = StoragePolicy::defaultDataSource() )
      : StoragePolicy( dataID, sg ), IndexingPolicy( elemID ), m_element( 0 ) {}
  /// o(1) version: provide storable key, element index AND element ptr
  /// USE CAREFULLY: no coherency checks, we just trust you!
  ElementLink( const ID_type& dataID, index_type elemID, ElementPointer pEl )
      : StoragePolicy( dataID, 0 ), IndexingPolicy( elemID ), m_element( pEl ) {}
  /// o(1) version: provide index (identifier) of owned object
  /// and a pointer to the storable
  ///@throws std::invalid_argument when the element is not found
  ElementLink( BaseConstReference data, index_type elemID,
               IProxyDict* sg = StoragePolicy::defaultDataSource() )
      : StoragePolicy( data, sg ), IndexingPolicy( elemID ), m_element( 0 ) {}
  // up to o(n) version: using a ref to the storable and to the element
  //! this will trigger a linear search for sequence
  // storables such as vectors and lists!
  // notice that the element argument is a pointer. This is to remove
  // an ambiguity with the previous constructor when the storable is a
  // container of integers (or more in general of types convertible to
  // index type. This constructor will throw when the pointer is NULL
  //  or when the element is not found
  // NOT YET  ElementLink(BaseConstReference data, ElementConstReference element,
  // NOT YET      DataSource* sg=StoragePolicy::defaultDataSource());
  //        throw (std::invalid_argument)
 
  /// \name Modifiers, use to make an ElementLink persistable
  //@{
  /// set link to point to given index: FAST
  void toIndexedElement( BaseConstReference data, index_type elementID );
  /// set link to point to given element: O(n) for sequences!
  bool toContainedElement( BaseConstReference data, ElementParameter element );
  /// set link storable to data object pointed by data
  void setStorableObject( BaseConstReference data ) { StoragePolicy::setData( data ); }
  //@}
 
  /// \name Accessors
  //@{
  /// @throws std::runtime_error when the element is not found
  ElementConstReference operator*() const;
 
  ElementConstPointer operator->() const { return cptr(); }
  operator ElementConstPointer() const { return cptr(); }
  ElementConstPointer cptr() const;
 
  bool isValid() const { return ( 0 != cptr() ); }
  bool operator!() const { return !isValid(); }
  //@}
 
private:
  /// cache element we are linking - mutable for cptr
  mutable ElementPointer m_element;
};
 
// inserters and extractors
 
template <class OS, typename STORABLE, class DLB, class IDX>
OS& operator<<( OS& os, ElementLink<STORABLE, DLB, IDX>& link );
 
template <class IS, typename STORABLE, class DLB, class IDX>
IS& operator>>( IS& is, ElementLink<STORABLE, DLB, IDX>& link );
 
#include "DataModel/ElementLink.icc"
 
#ifndef DATAMODEL_TOOLS_PLAINPTRSTORAGE_H
#  include "DataModel/tools/PlainPtrStorage.h"
#endif
 
/// @class PlainPtrElementLink
/// @brief helper struct to be used as type generator
/// e.g. PlainPtrElementLink<vector<int> >::type
template <typename STORABLE,
          class IndexingPolicy = typename SG::GenerateIndexingPolicy<STORABLE>::type>
struct PlainPtrElementLink {
  typedef ElementLink<STORABLE, PlainPtrStorage<STORABLE>, IndexingPolicy> type;
};
#endif /*ELEMENTLINK_H*/