AthToolSupport/AsgDataHandles/AsgDataHandles/WriteDecorHandle.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_WRITE_DECOR_HANDLE_H
#define ASG_DATA_HANDLES_WRITE_DECOR_HANDLE_H
 
#ifndef XAOD_STANDALONE
#include <StoreGate/WriteDecorHandle.h>
#else
 
#include "AsgDataHandles/WriteDecorHandleKey.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 WriteDecorHandle
  : public ReadHandle<T>
{
public:
  typedef ReadHandle<T> Base;
 
  typedef SG::AuxElement::Decorator<D> accessor_t;
 
  typedef typename accessor_t::reference_type
    reference_type;
 
  typedef typename accessor_t::container_pointer_type
    container_pointer_type;
 
  explicit WriteDecorHandle (const WriteDecorHandleKey<T>& key);
 
 
  explicit WriteDecorHandle (const WriteDecorHandleKey<T>& key,
                             const EventContext& ctx);
 
 
//   /**
//    * @brief Copy constructor.
//    */
//   WriteDecorHandle (const WriteDecorHandle& rhs);
 
 
//   /**
//    * @brief Move constructor.
//    */
//   WriteDecorHandle (WriteDecorHandle&& rhs);
 
 
//   /**
//    * @brief Destructor.  This will lock the decoration.
//    */
//   ~WriteDecorHandle();
 
 
//   /**
//    * @brief Assignment operator.
//    */
//   WriteDecorHandle& operator= (const WriteDecorHandle& rhs);
 
 
//   /**
//    * @brief Move operator.
//    */
//   WriteDecorHandle& operator= (WriteDecorHandle&& rhs);
 
 
  bool isPresent() const;
 
 
//   /**
//    * @brief Explicitly set the event store.
//    * @param store The new event store.
//    *
//    * This implicitly does a reset().
//    *
//    * We need to override this so that the setting gets made on the container
//    * handle as well.
//    */
//   virtual StatusCode setProxyDict (IProxyDict* store) override;
 
  
  reference_type operator() (const AuxElement& e);
 
 
//   /**
//    * @brief Fetch the variable for one element, as a reference.
//    * @param index The index of the desired element.
//    *
//    * This looks up the variable in the object referenced by this handle.
//    * For a standalone object, pass an index of 0.
//    */
//   reference_type operator() (size_t index);
 
 
//   /**
//    * @brief Get a pointer to the start of the auxiliary data array,
//    *        for the referenced object.
//    */
//   container_pointer_type
//   getDecorationArray();
 
 
  bool isAvailable();
 
 
//   /**
//    * @brief Return the aux id for this variable.
//    */
//   SG::auxid_t auxid() const;
 
 
  // /**
  //  * @brief Return the mode (read/write/update) for this handle.
  //  */
  // Gaudi::DataHandle::Mode mode() const;
 
 
  std::string decorKey() const;
 
 
// private:
//   /**
//    * @brief Retrieve an object from StoreGate.
//    * @param quiet If true, suppress failure messages.
//    *
//    * Extended for decoration handles: when we first retrieve the object,
//    * we make an alias for the decoration and also create the decoration itself.
//    */
//   virtual void* typeless_dataPointer_impl (bool quiet) override;
 
 
  bool isAvailable (std::true_type);
 
 
  bool isAvailable (std::false_type);
 
 
//   /** 
//    * @brief Return the referenced object as a @c SG::AuxVectorData.
//    *        Specialization for the case of a standalone object
//    *        (@c T derives from @c SG::AuxElement).
//    */
//   const SG::AuxVectorData* vectorData (std::true_type);
 
 
//   /** 
//    * @brief Return the referenced object as a @c SG::AuxVectorData.
//    *        Specialization for the case of a container
//    *        (@c T does not derive from @c SG::AuxElement).
//    */
//   const SG::AuxVectorData* vectorData (std::false_type);
 
 
//   /** 
//    * @brief Return the referenced object as a @c SG::AuxVectorData.
//    *
//    * If @c T is a container object, then this should be the object itself.
//    * But if it is a standalone object, deriving from @c SG::AuxElement,
//    * then we need to call container() on the object.
//    */
//   const SG::AuxVectorData* vectorData();
 
 
  std::string m_decorKey;
 
 
  accessor_t m_acc;
 
//   bool m_madeAlias;
};
 
 
// /**
//  * @brief Return a @c WriteDecorHandle 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>
// WriteDecorHandle<T, D> makeHandle (const WriteDecorHandleKey<T>& key);
 
 
// /**
//  * @brief Return a @c WriteDecorHandle 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>
// WriteDecorHandle<T, D> makeHandle (const WriteDecorHandleKey<T>& key,
//                                    const EventContext& ctx);
 
 
template <class T>
void makeHandle (const WriteDecorHandleKey<T>& key);
template <class T>
void makeHandle (const WriteDecorHandleKey<T>& key,
                 const EventContext& ctx);
 
 
} // namespace SG
 
 
#include "AsgDataHandles/WriteDecorHandle.icc"
 
 
#endif
 
#endif