Event/GeneratorObject/include/DataModel/DataLink.h

Go to the documentation of this file.

#ifndef DATAMODEL_DATALINK_H
#define DATAMODEL_DATALINK_H
 
#ifndef DATAMODEL_TOOLS_DATAPROXYSTORAGE_H
#  include "DataModel/tools/DataProxyStorage.h"
#endif
 
#ifndef __EXCEPTION__
#  include <exception>
#endif
 
/** @class DataLink
 * @brief a persistable pointer to a STORABLE (data object)
 *
 * @param STORABLE        pointed-to data object type
 * @param StoragePolicy   STORABLE management policy (defaults to DataProxyStorage)
 *
 * @author ATLAS Collaboration
 * $Id: DataLink.h,v 1.2 2003/04/16 01:32:52 calaf Exp $
 **/
 
class IProxyDict;
 
template <typename STORABLE, class StoragePolicy = DataProxyStorage<STORABLE>>
class DataLink : public StoragePolicy {
public:
  typedef typename StoragePolicy::ID_type ID_type;
  // iterator-like  tdefs
  typedef typename StoragePolicy::value_type      value_type;
  typedef typename StoragePolicy::pointer         pointer;
  typedef typename StoragePolicy::const_pointer   const_pointer;
  typedef typename StoragePolicy::reference       reference;
  typedef typename StoragePolicy::const_reference const_reference;
 
  // CONSTRUCTORS
  /// links to the default object of type STORABLE
  DataLink( IProxyDict* sg = StoragePolicy::defaultDataSource() ) : StoragePolicy( sg ) {}
 
  /// link to a STORABLE using a transient ref to it
  DataLink( const_reference data, IProxyDict* sg = StoragePolicy::defaultDataSource() )
      : StoragePolicy( data, sg ) {}
  /// link to a STORABLE using a transient ptr to it (must be non NULL)
  ///@throws std::invalid_argument
 
  DataLink( const_pointer pdata, IProxyDict* sg = StoragePolicy::defaultDataSource() )
      : StoragePolicy( pdata, sg ) {}
 
  /// link to a STORABLE using its ID
  DataLink( const ID_type& dataID, IProxyDict* sg = StoragePolicy::defaultDataSource() )
      : StoragePolicy( dataID, sg ) {}
 
  // SETTERS, use to make a DataLink persistable
 
  /// set link to data object pointed by data
  void toStorableObject( const_reference data ) { StoragePolicy::setData( data ); }
  /// set link to default data object (of type const_reference)
  void toDefaultObject() { this->clear(); }
  /// set link using data object key
  void toIdentifiedObject( const ID_type& dataID ) { StoragePolicy::setData( dataID ); }
 
  // ACCESSORS
 
  const_reference operator*() const { return StoragePolicy::getDataRef(); }
 
  const_pointer operator->() const { return StoragePolicy::getDataPtr(); }
  operator const_pointer() const { return StoragePolicy::getDataPtr(); }
  const_pointer cptr() const { return StoragePolicy::getDataPtr(); }
 
  bool isValid() const;
  bool operator!() const { return !isValid(); }
 
  /// SG internal use only
  //@{
  using StoragePolicy::clear;
  using StoragePolicy::reset;
  //@}
};
 
/////////////////////////////////////////////////////////////////
// inserters and extractors
 
template <class OS, typename STORABLE, class StoragePolicy>
OS& operator<<( OS& os, DataLink<STORABLE, StoragePolicy>& link );
 
template <class IS, typename STORABLE, class StoragePolicy>
IS& operator>>( IS& is, DataLink<STORABLE, StoragePolicy>& link );
 
#include "DataModel/DataLink.icc"
 
#ifndef DATAMODEL_TOOLS_PLAINPTRSTORAGE_H
#  include "DataModel/tools/PlainPtrStorage.h"
#endif
// helper struct to be used as type generator
// e.g. PlainPtrDataLink<vector<int> >::type
 
template <typename STORABLE> struct PlainPtrDataLink {
  typedef DataLink<STORABLE, PlainPtrStorage<STORABLE>> type;
};
#endif /*DATALINK_H*/