MultiAssociationToolMulti.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
/**
 * @file D3PDMakerUtils/MultiAssociationToolMulti.icc
 * @author scott snyder <snyder@bnl.gov>
 * @date Jun, 2012
 * @brief A specialization of MultiAssociationTool that can accept one
 *        of several types.
 */
 
 
//**************************************************************************
// Single-argument specialization
//
 
 
namespace D3PD {
 
 
/**
 * @brief Standard Gaudi tool constructor.
 * @param type The name of the tool type.
 * @param name The tool name.
 * @param parent The tool's Gaudi parent.
 */
template <class T0, class TO_T>
MultiAssociationTool<Types<T0>, TO_T>::MultiAssociationTool
  (const std::string& type,
   const std::string& name,
   const IInterface* parent)
    : MultiAssociationToolTo<TO_T> (type, name, parent),
      m_which(0),
      m_fromTypeinfo(0)
{
}
 
 
/**
 * @brief Configure during initialization: type-check.
 * @param tree Our parent for tuple making.
 * @param ti Gives the type of the object being passed to @c fillUntyped.
 *
 * @c configureD3PD should check that the type of the object coming as input
 * is compatible with what it expects, and raise an error otherwise.
 */
template <class T0, class TO_T>
StatusCode
MultiAssociationTool<Types<T0>, TO_T>::configureD3PD
  (IAddVariable* tree,
   const std::type_info& ti)
{
  std::vector<const std::type_info*> tis;
  push_ti (tis);
  StatusCode sc = this->configureMulti (tree, ti, tis, m_which);
  if (m_which < tis.size())
    m_fromTypeinfo = tis[m_which];
  return sc;
}
 
 
/**
 * @brief Return the @c std::type_info for the source of the association.
 */
template <class T0, class TO_T>
const std::type_info&
MultiAssociationTool<Types<T0>, TO_T>::fromTypeinfo() const
{
  return *m_fromTypeinfo;
}
 
 
/**
 * @brief Return the target object.
 * @param p The source object for the association.
 *
 * Return the target of the association, or 0.
 * Should be of the type given by @c typeinfo.
 */
template <class T0, class TO_T>
StatusCode
MultiAssociationTool<Types<T0>, TO_T>::resetUntyped
  (const void* p)
{
  p = this->doConversion (p);
  if (!p) return StatusCode::FAILURE;
  return doResetUntyped (p, 0);
}
 
 
/**
 * @brief Helper to decide which which @c reset method to call.
 *
 * This either calls @c reset using the last type
 * in our template argument list, or chains to the base class.
 *
 * It's virtual so that we can call the most-derived one from
 * @c resetUntyped in the base class, but we also declare it as inline
 * so that the base class chaining can be inlined.
 */
template <class T0, class TO_T>
inline
StatusCode
MultiAssociationTool<Types<T0>, TO_T>::doResetUntyped (const void* p, size_t /*count*/)
{
  return this->reset (*reinterpret_cast<const T0*> (p));
}
 
 
/**
 * @brief Helper to collect the list of @c type_info's that we accept.
 *
 * This first chains to the base class to pick up its list.
 * Then we add the @c type_info corresponding to the last type
 * in the template argument list.
 */
template <class T0, class TO_T>
void
MultiAssociationTool<Types<T0>, TO_T>::push_ti (std::vector<const std::type_info*>& tis)
{
  tis.reserve (1);
  tis.push_back (&typeid(T0));
}
 
 
/**
 * @brief Release an object retrieved from the association.
 * @param p The object to release.
 *
 * Call this when you are done with the object returned by
 * @c next().  The default implementation is a no-op,
 * but if the association dynamically allocated the object which
 * it returned, this gives it a chance to free it.
 */
template <class T0, class U0>
inline
void
MultiAssociationTool<Types<T0>, Types<U0> >::releaseElement
  (const U0* /*p*/)
{
}
 
 
/**
 * @brief Release an object retrieved from the association.
 * @param p The object to release.
 *
 * Call this when you are done with the object returned by
 * @c nextUntyped().  The default implementation is a no-op,
 * but if the association dynamically allocated the object which
 * it returned, this gives it a chance to free it.
 */
template <class T0, class U0>
inline
void
MultiAssociationTool<Types<T0>, Types<U0> >::releaseElementUntyped (const void* p)
{
  this->releaseElement (reinterpret_cast<const U0*> (p));
}
 
 
//**************************************************************************
 
 
/**
 * @brief Standard Gaudi tool constructor.
 * @param type The name of the tool type.
 * @param name The tool name.
 * @param parent The tool's Gaudi parent.
 */
template <class T0, class U0>
MultiAssociationTool<Types<T0>, Types<U0> >::MultiAssociationTool
  (const std::string& type,
   const std::string& name,
   const IInterface* parent)
    : MultiAssociationTool<Types<T0>, U0> (type, name, parent)
{
  // cppcheck-suppress missingReturn; false positive
}
 
 
/**
 * @brief Return a pointer to the next element in the association.
 *
 * This overload is not used for the case where we can return multiple
 * output types.  In this case, @c next takes a dummy pointer to the
 * input type in order to fix the type.
 */
template <class T0, class U0>
const U0*
MultiAssociationTool<Types<T0>, Types<U0> >::next()
{
  std::abort();
}
 
 
/**
 * @brief Return the element type for the target of the association.
 *
 * I.e., @c nextUntyped returns a pointer to this type.
 */
template <class T0, class U0>
const std::type_info&
MultiAssociationTool<Types<T0>, Types<U0> >::elementTypeinfo() const
{
  return typeid (U0);
}
 
 
/**
 * @brief Return a pointer to the next element in the association.
 *
 * Return 0 when the association has been exhausted.
 */
template <class T0, class U0>
const void*
MultiAssociationTool<Types<T0>, Types<U0> >::nextUntyped ()
{
  return next ((T0*)0);
}
 
 
//**************************************************************************
// Multiple-argument specializations
//
 
 
template <class T0, class TO_T>
class MaybeNext
{
public:
  void next (int) {}
};
 
 
template <class T0, class U0, class... TYPES>
class MaybeNext<T0, Types<U0, TYPES...> >
{
public:
  virtual const U0* next (const T0* dum) = 0;
};
 
 
/**
 * @brief A specialization of MultiAssociationTool that can accept one
 *        of several types.
 *
 * This specialization is for the case of more than one argument.
 */
template <class TO_T, class T0, class... TYPES>
class MultiAssociationTool<Types<T0, TYPES...>, TO_T>
  : public MultiAssociationTool<Types<TYPES...>, ButFirstType_t<TO_T> >,
    public MaybeNext<T0, TO_T>
{
public:
  using Base = MultiAssociationTool<Types<TYPES...>, ButFirstType_t<TO_T> >;
 
  using Base::Base;
 
  virtual void push_ti (std::vector<const std::type_info*>& tis) override
  {
    tis.reserve (1 + sizeof... (TYPES));
    tis.push_back (&typeid(T0));
    Base::push_ti (tis);
  }
 
  using Base::reset;
  virtual StatusCode reset (const T0& p) = 0;
 
  using Base::next;
  using MaybeNext<T0, TO_T>::next;
 
  virtual StatusCode doResetUntyped (const void* p, size_t count) override
  {
    if (this->m_which == count)
      return this->reset (*reinterpret_cast<const T0*> (p));
    return Base::doResetUntyped (p, count+1);
  }
};
 
 
} // namespace D3PD