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
{
  struct ColumnAccessorOptions final
  {
    std::string replacesColumn {};
 

    bool isOptional = false;
 

    bool addMTDependency = false;
 

    std::vector<std::string> internalLinkTargetNames {};
 
    ColumnInfo makeColumnInfo () const
    {
      ColumnInfo info;
      info.replacesColumn = replacesColumn;
      info.isOptional = isOptional;
      info.linkTargetNames = internalLinkTargetNames;
      return info;
    }
  };
 
 
 
  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;
  };
 
 
 
  namespace detail
  {
 
    template<typename CT,ColumnAccessMode CAM,ColumnarMode CM> class ContainerFreeAccessor final
    {
    public:
      static constexpr bool isDefined = false;
    };
 
 

 
    template<typename CT,ColumnarMode CM> class MemoryAccessor final
    {
    public:
      static constexpr bool isDefined = false;
    };
 
 
 
    template<typename CT,ColumnarMode CM>
      requires ((std::is_integral_v<CT> || std::is_floating_point_v<CT>) && !std::is_same_v<CT,bool>)
    class MemoryAccessor<CT,CM> final
    {
    public:
      static constexpr bool isDefined = true;
      static constexpr bool viewIsReference = true;
      static constexpr bool hasSetter = false;
      using MemoryType = CT;
 
      static void updateColumnInfo (ColumnInfo& /*info*/) {}
    };
  }
 
 

  template<ContainerIdConcept CI,typename CT,ColumnAccessMode CAM,typename CM> class AccessorTemplate;
 

  template<typename CT> struct NativeColumn final {};
  namespace detail
  {
    template<typename CT,ColumnarMode CM>
    class MemoryAccessor<NativeColumn<CT>,CM> final
    {
    public:
      static constexpr bool isDefined = true;
      static constexpr bool viewIsReference = true;
      static constexpr bool hasSetter = false;
      using MemoryType = CT;
 
      static void updateColumnInfo (ColumnInfo& /*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");
  };
 
  namespace detail
  {
    template<typename UT,typename CT,ColumnarMode CM>
    class MemoryAccessor<RetypeColumn<UT,CT>,CM> final
    {
    public:
      static constexpr bool isDefined = true;
      static constexpr bool viewIsReference = false;
      static constexpr bool hasSetter = false;
      using MemoryType = CT;
 
      static void updateColumnInfo (ColumnInfo& /*info*/) {}
      static auto makeViewer (auto&&)
      {
        return [] (const auto& value) {return static_cast<UT>(value);};
      }
    };
  }
 
 
 

 
  template<ContainerIdConcept CI,typename CT,ColumnAccessMode CAM,typename CM>
  void resetAccessor (AccessorTemplate<CI,CT,CAM,CM>& accessor, ColumnarTool<CM>& columnBase, const std::string& name, ColumnAccessorOptions&& options = {})
  {
    accessor = AccessorTemplate<CI,CT,CAM,CM> (columnBase, name, std::move (options));
  }
 
 
 
 
 
  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