ColumnarToolArray.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
/// @author Nils Krumnack
 
 
#include <AsgMessaging/StatusCode.h>
#include <ColumnarCore/ContainerId.h>
#include <ColumnarCore/ObjectRange.h>
#include <ColumnarInterfaces/ColumnInfo.h>
#include <ColumnarInterfaces/IColumnarTool.h>
#include <memory>
 
namespace columnar
{
  struct ColumnAccessorDataArray;
  struct ColumnarToolDataArray;
 
  /// @brief a common base class for all columnar tools using an array mode
  ///
  /// Essentially the idea is that there are multiple columnar modes
  /// that have the same basic structure of having an underlying array
  /// with one entry per column, pointing to the column data. So this
  /// class contains all the common functionality for such modes, and
  /// the actual `ColumnarTool` specializations inherit from this class
  /// and then do the mode-specific wrapping (to avoid mixing modes
  /// within a tool).
 
  class ColumnarToolArray : public IColumnarTool
  {
    /// Common Public Members
    /// =====================
  public:
 
    /// @brief whether this tool can only be called for a single event
    static constexpr bool singleEvent = false;
 
 
    /// @brief standard (virtual) destructor
    virtual ~ColumnarToolArray ();
 
 
    /// @brief initialize the columns/column handles
    ///
    /// This should be called at the end of initialize after all data handles
    /// have been declared.
    StatusCode initializeColumns ();
 
 
 
    /// Inherited Members from IColumnarTool
    /// ====================================
  public:
 
    std::vector<ColumnInfo> getColumnInfo () const final;
    void renameColumn (const std::string& from, const std::string& to) final;
    void setColumnIndex (const std::string& name, std::size_t index) final;
 
 
 
    /// Internal/Detail Members
    /// =======================
    ///
    /// These are technically public members, but are not intended for
    /// the user to call, and are only public because they need to be
    /// for other parts of the prototype to call.
  public:
 
    void setContainerUserName (std::string_view ciName, const std::string& name);
    void addColumn (const std::string& name, ColumnAccessorDataArray *accessorData, ColumnInfo&& info);
 
 
    /// Protected Members
    /// =================
  protected:
 
    friend struct ColumnarToolDataArray;
 
 
    // most of our data is stored in a pimpl structure
    std::shared_ptr<ColumnarToolDataArray> m_data;
 
    // we may have to access the event offset column, so hard-coding
    // that here
    unsigned m_eventsIndex = 0u;
    std::unique_ptr<ColumnAccessorDataArray> m_eventsData;
 
 
    /// standard constructors
    ColumnarToolArray (ColumnarToolArray* val_parent);
    ColumnarToolArray (const ColumnarToolArray&) = delete;
    ColumnarToolArray& operator = (const ColumnarToolArray&) = delete;
 
    /// @brief add the given sub-tool
    void addSubtool (ColumnarToolArray& subtool);
  };
    
 
 
  template<ColumnarArrayMode CM>
  class ColumnarTool<CM> : public ColumnarToolArray
  {
    /// Common Public Members
    /// =====================
  public:
 
    ColumnarTool () : ColumnarToolArray (nullptr) {};
    explicit ColumnarTool (ColumnarTool<CM>* val_parent) : ColumnarToolArray (val_parent) {};
 
 
    /// @brief add the given sub-tool
    void addSubtool (ColumnarTool<CM>& subtool) {
      ColumnarToolArray::addSubtool (subtool); }
 
 
    /// @brief call the tool for the given event range
    virtual void callEvents (ObjectRange<ContainerId::eventContext,CM> /*events*/) const {
      throw std::runtime_error ("tool didn't implement callEvents");}
 
 
 
    /// Inherited Members from IColumnarTool
    /// ====================================
  public:
 
    void callVoid (void **data) const final {
      auto eventsOffset = static_cast<const ColumnarOffsetType*> (data[m_eventsIndex]);
      callEvents (ObjectRange<ContainerId::eventContext,CM> (data, eventsOffset[0], eventsOffset[1])); }
  };
}