AthToolSupport/AsgDataHandles/AsgDataHandles/ReadDecorHandle.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
 
/*
 * Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration.
 */
 
#ifndef ASG_DATA_HANDLES_READ_DECOR_HANDLE_H
#define ASG_DATA_HANDLES_READ_DECOR_HANDLE_H
 
#ifndef XAOD_STANDALONE
#include <StoreGate/ReadDecorHandle.h>
#else
 
#include "AsgDataHandles/ReadDecorHandleKey.h"
#include "AsgDataHandles/ReadHandle.h"
#include "AsgDataHandles/DecorKeyHelpers.h"
#include "AthContainers/AuxElement.h"
// #include "GaudiKernel/EventContext.h"
// #include <type_traits>
 
 
namespace SG {
 
 
template <class T, class D>
class ReadDecorHandle
  : public ReadHandle<T>
{
public:
  typedef ReadHandle<T> Base;
 
  typedef SG::AuxElement::ConstAccessor<D> accessor_t;
 
  typedef typename accessor_t::const_reference_type
    const_reference_type;
 
  typedef typename accessor_t::const_container_pointer_type
    const_container_pointer_type;
 
 
  explicit ReadDecorHandle (const ReadDecorHandleKey<T>& key);
 
 
  explicit ReadDecorHandle (const ReadDecorHandleKey<T>& key,
                            const EventContext& ctx);
 
 
//   /**
//    * @brief Copy constructor.
//    */
//   ReadDecorHandle (const ReadDecorHandle& rhs);
 
 
//   /**
//    * @brief Move constructor.
//    */
//   ReadDecorHandle (ReadDecorHandle&& rhs);
 
 
//   /**
//    * @brief Assignment operator.
//    */
//   ReadDecorHandle& operator= (const ReadDecorHandle& rhs);
 
 
//   /**
//    * @brief Move operator.
//    */
//   ReadDecorHandle& operator= (ReadDecorHandle&& rhs);
 
  
  bool isPresent() const;
 
 
  const_reference_type operator() (const AuxElement& e) const;
 
 
  const_reference_type operator() (size_t index);
 
 
//   /**
//    * @brief Get a pointer to the start of the auxiliary data array,
//    *        for the referenced object.
//    */
//   const_container_pointer_type
//   getDataArray();
 
 
  bool isAvailable();
 
 
//   /**
//    * @brief Return the aux id for this variable.
//    */
//   SG::auxid_t auxid() const;
 
 
  std::string decorKey() const;
 
  
private:
  const SG::AuxVectorData* vectorData (std::true_type);
 
 
  const SG::AuxVectorData* vectorData (std::false_type);
 
 
  const SG::AuxVectorData* vectorData();
 
 
  std::string m_decorKey;
 
 
  accessor_t m_acc;
};
 
 
// /**
//  * @brief Return a @c ReadDecorHandle referencing @c key.
//  * @param key The key object holding the clid/key/store.
//  *
//  * This will raise an exception if the StoreGate key is blank,
//  * or if the event store cannot be found.
//  *
//  * The type of the decoration must be included as an explicit template parameter:
//  *
//  *@code
//  *   auto handle = SG::makeHandle<float> (key);
//  @endcode
//  *
//  * Note that @c D comes first in the argument list.  It's given explicitly,
//  * while @c T is inferred from @c key.
//  */
// template <class D, class T>
// ReadDecorHandle<T, D> makeHandle (const ReadDecorHandleKey<T>& key);
 
 
// /**
//  * @brief Return a @c ReadDecorHandle referencing @c key for an explicit context.
//  * @param key The key object holding the clid/key/store.
//  * @param ctx The event context.
//  *
//  * This will raise an exception if the StoreGate key is blank,
//  * or if the event store cannot be found.
//  *
//  * If the default event store has been requested, then the thread-specific
//  * store from the event context will be used.
//  *
//  * The type of the decoration must be included as an explicit template parameter:
//  *
//  *@code
//  *   auto handle = SG::makeHandle<float> (key, ctx);
//  @endcode
//  *
//  * Note that @c D comes first in the argument list.  It's given explicitly,
//  * while @c T is inferred from @c key.
//  */
// template <class D, class T>
// ReadDecorHandle<T, D> makeHandle (const ReadDecorHandleKey<T>& key,
//                                   const EventContext& ctx);
 
 
// /**
//  * @brief These two signatures are to catch cases where the explicit
//  *        template argument is omitted from the @c makeHandle call
//  *        and give an error tailored to that.  Otherwise, the @c makeHandle
//  *        call for @c ReadHandle would match, potentially giving a much
//  *        more confusing error.
//  */
// template <class T>
// void makeHandle (const ReadDecorHandleKey<T>& key);
// template <class T>
// void makeHandle (const ReadDecorHandleKey<T>& key,
//                  const EventContext& ctx);
 
 
} // namespace SG
 
 
#include "AsgDataHandles/ReadDecorHandle.icc"
 
#endif
 
#endif // not STOREGATE_READDECORHANDLE_READDECORHANDLE_H