BlockFillerToolMulti.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
/**
 * @file D3PDMakerUtils/BlockFillerToolMulti.icc
 * @author scott snyder <snyder@bnl.gov>
 * @date Nov, 2011
 * @brief A specialization of BlockFillerTool 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>
BlockFillerTool<Types<T0> >::BlockFillerTool
  (const std::string& type,
   const std::string& name,
   const IInterface* parent)
  : BlockFillerToolImpl (type, name, parent),
    m_which (0)
{
  // cppcheck-suppress missingReturn; false positive
}
 
 
/**
 * @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>
StatusCode
BlockFillerTool<Types<T0> >::configureD3PD
  (IAddVariable* tree,
   const std::type_info& ti)
{
  std::vector<const std::type_info*> tis;
  push_ti (tis);
  return this->configureImpl (tree, ti, tis, m_which);
}
 
 
/**
 * @brief Helper to decide which which @c fill method to call.
 *
 * This either calls @c fill / @c fillAgain 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 fillUntyped in the base class, but we also declare it as inline
 * so that the base class chaining can be inlined.
 */
template <class T0>
inline
StatusCode
BlockFillerTool<Types<T0> >::doFillUntyped (const void* p, bool again, size_t count)
{
  if (m_which == count) {
    if (again)
      return this->fillAgain (*reinterpret_cast<const T0*> (p));
    return this->fill (*reinterpret_cast<const T0*> (p));
  }
  std::abort();
}
 
 
/**
 * @brief Fill one block.
 * @param p The input object.
 * @param again Set if this is a subsequent call requested by an AGAIN return
 *
 * This is called once per object.  The type of the object at which @c p
 * points is given by the @c ti argument to @c configureD3PD.  The caller
 * is responsible for arranging that all the pointers for booked variables
 * are set appropriately upon entry.
 *
 * If the return status is the special code @c AGAIN (defined above),
 * then this filler tool wants to make multiple entries.
 * The parent should set up to capture a new `row' and run
 * through the list of block filler
 * tools again, but for this tool call @c fillAgainUntyped
 * instead of @c fillUntyped.  This should be repeated as long
 * as @c fillAgainUntyped returns @c AGAIN.
 *
 * Once @c fillUntyped returns @c AGAIN, the parent should
 * call @c fillUntyped with the same @a p argument and @c again
 * set to @c true.  This continues until @c fillUntyped returns something
 * other than @c AGAIN.
 *
 * Not all parents may support this.  In that case, returning
 * @c AGAIN will be treated as an error.
 */
template <class T0>
StatusCode
BlockFillerTool<Types<T0> >::fillUntyped (const void* p, bool again /*= false*/)
{
  if (!p) return StatusCode::SUCCESS;
  StatusCode stat = convert (p);
  if (stat.isFailure())
    return stat;
  return doFillUntyped (p, again, 0);
}
 
 
/**
 * @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>
void
BlockFillerTool<Types<T0> >::push_ti (std::vector<const std::type_info*>& tis)
{
  tis.reserve (1);
  tis.push_back (&typeid(T0));
}
 
 
/**
 * @brief A specialization of BlockFillerTool that can accept one
 *        of several types.
 *
 * This specialization is for the case of more than one argument.
 */
template <class T0, class... TYPES>
class BlockFillerTool<Types<T0, TYPES...> >
  : public BlockFillerTool<Types<TYPES...> >
{
public:
  using Base = BlockFillerTool<Types<TYPES...> >;
 
  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::fill;
  virtual StatusCode fill (const T0& /*p*/) = 0;
 
  using Base::fillAgain;
  virtual StatusCode fillAgain (const T0& p) { return this->fill(p); }
 
  virtual StatusCode doFillUntyped (const void* p, bool again, size_t count) override
  {
    if (this->m_which == count) {
      if (again)
        return this->fillAgain (*reinterpret_cast<const T0*> (p));
      return this->fill (*reinterpret_cast<const T0*> (p));
    }
    return Base::doFillUntyped (p, again, count+1);
  }
};
 
 
} // namespace D3PD