ColumnAccessor.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
 
 
#ifndef COLUMNAR_CORE_COLUMN_ACCESSOR_H
#define COLUMNAR_CORE_COLUMN_ACCESSOR_H
 
#include "AthContainers/ConstAccessor.h"
#include "AthContainers/Accessor.h"
#include "AthContainers/Decorator.h"
#include <ColumnarCore/ColumnarTool.h>
#include <ColumnarCore/ObjectId.h>
#include <ColumnarCore/ObjectRange.h>
#include <ColumnarCore/ContainerId.h>
#include <ColumnarInterfaces/ColumnInfo.h>
#include <span>
#include <type_traits>
 
namespace columnar
{
  template<ColumnAccessMode CAM> struct ColumnAccessModeTraits;
 
  template<> struct ColumnAccessModeTraits<ColumnAccessMode::input>
  {
    template<typename T> using XAODAccessor = SG::ConstAccessor<T>;
    template<typename T> using ColumnType = const T;
  };
 
  template<> struct ColumnAccessModeTraits<ColumnAccessMode::output>
  {
    template<typename T> using XAODAccessor = SG::Decorator<T>;
    template<typename T> using ColumnType = T;
  };
 
  template<> struct ColumnAccessModeTraits<ColumnAccessMode::update>
  {
    template<typename T> using XAODAccessor = SG::Accessor<T>;
    template<typename T> using ColumnType = T;
  };
 
 
 
  template<ContainerIdConcept CI,typename CT,ColumnAccessMode CAM,typename CM> class AccessorTemplate;
 
 
  template<typename CT,typename CM>
  struct ColumnTypeTraits final
  {
    static constexpr bool isNativeType = false;
    static constexpr bool useConvertInput = false;
    static constexpr bool useConvertWithDataInput = false;
    static ColumnInfo& updateColumnInfo (ColumnarTool<CM>& /*columnBase*/, ColumnInfo& info) {return info;}
  };
 
  template<typename CT,typename CM>
    requires ((std::is_integral_v<CT> || std::is_floating_point_v<CT>) && !std::is_same_v<CT,bool>)
  struct ColumnTypeTraits<CT,CM> final
  {
    using ColumnType = CT;
    static constexpr bool isNativeType = true;
    static constexpr bool useConvertInput = false;
    static constexpr bool useConvertWithDataInput = false;
    static ColumnInfo& updateColumnInfo (ColumnarTool<CM>& /*columnBase*/, ColumnInfo& info) {return info;}
  };
 
  template<typename CT> struct NativeColumn final {};
  template<typename CT,typename CM>
  struct ColumnTypeTraits<NativeColumn<CT>,CM> final
  {
    using ColumnType = CT;
    static constexpr bool isNativeType = true;
    static constexpr bool useConvertInput = false;
    static constexpr bool useConvertWithDataInput = false;
    static ColumnInfo& updateColumnInfo (ColumnarTool<CM>& /*columnBase*/, ColumnInfo& info) {return info;}
  };
 
 
  template<typename UT,typename CT> struct RetypeColumn final
  {
    static_assert (!std::is_const_v<CT>, "CT must not be const");
    static_assert (!std::is_const_v<UT>, "UT must not be const");
  };
 
  template<typename UT,typename CT,typename CM>
  struct ColumnTypeTraits<RetypeColumn<UT,CT>,CM> final
  {
    using ColumnType = CT;
    using UserType = UT;
    static constexpr bool isNativeType = false;
    static constexpr bool useConvertInput = true;
    static constexpr bool useConvertWithDataInput = false;
    static ColumnInfo& updateColumnInfo (ColumnarTool<CM>& /*columnBase*/, ColumnInfo& info) {return info;}
    static UT convertInput (const CT& value) {return UT (value);}
  };
 
 
 
  // the accessor specialization for type conversions
  template<ContainerIdConcept CI,typename CT,typename CM>
    requires (ColumnTypeTraits<CT,CM>::useConvertInput || ColumnTypeTraits<CT,CM>::useConvertWithDataInput)
  class AccessorTemplate<CI,CT,ColumnAccessMode::input,CM> final
  {
  public:
 
    using ColumnType = typename ColumnTypeTraits<CT,CM>::ColumnType;
    using UserType = typename ColumnTypeTraits<CT,CM>::UserType;
 
    AccessorTemplate () = default;
 
    AccessorTemplate (ColumnarTool<CM>& columnBase, const std::string& name, ColumnInfo&& info = {})
      : m_base (columnBase, name, std::move (ColumnTypeTraits<CT,CM>::updateColumnInfo(columnBase, info)))
    {}
 
    [[nodiscard]] decltype(auto) operator () (ObjectId<CI,CM> id) const noexcept
    {
      if constexpr (ColumnTypeTraits<CT,CM>::useConvertWithDataInput)
        return ColumnTypeTraits<CT,CM>::convertInput (id.getData(), m_base(id));
      else
        return ColumnTypeTraits<CT,CM>::convertInput (m_base(id));
    }
 
    [[nodiscard]] bool isAvailable (ObjectId<CI,CM> id) const noexcept
    {
      return m_base.isAvailable (id);
    }
 
    [[nodiscard]] std::optional<UserType> getOptional (ObjectId<CI,CM> id) const
    {
      if (m_base.isAvailable (id))
        return operator()(id);
      else
        return std::nullopt;
    }
 
  private:
    AccessorTemplate<CI,ColumnType,ColumnAccessMode::input,CM> m_base;
  };
 
 
 
 
 
  template<ContainerIdConcept CI,typename CT,ColumnAccessMode CAM,typename CM>
  void resetAccessor (AccessorTemplate<CI,CT,CAM,CM>& accessor, ColumnarTool<CM>& columnBase, const std::string& name, ColumnInfo&& info = {})
  {
    accessor = AccessorTemplate<CI,CT,CAM,CM> (columnBase, name, std::move (info));
  }
 
 
 
 
 
  template<ContainerIdConcept CI,typename CT,typename CM=ColumnarModeDefault> using ColumnAccessor = AccessorTemplate<CI,CT,ColumnAccessMode::input,CM>;
  template<ContainerIdConcept CI,typename CT,typename CM=ColumnarModeDefault> using ColumnDecorator = AccessorTemplate<CI,CT,ColumnAccessMode::output,CM>;
  template<ContainerIdConcept CI,typename CT,typename CM=ColumnarModeDefault> using ColumnUpdater = AccessorTemplate<CI,CT,ColumnAccessMode::update,CM>;
}
 
#include "ColumnAccessorXAOD.icc"
#include "ColumnAccessorArray.icc"
 
#endif