ColumnarDef.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef COLUMNAR_CORE_COLUMNAR_DEF_H
#define COLUMNAR_CORE_COLUMNAR_DEF_H
 
#include <cstdint>
#include <stdexcept>
 
namespace columnar
{
  // This checks that COLUMNAR_DEFAULT_ACCESS_MODE is indeed defined, plus makes it
  // available for use with `if constexpr`.
  constexpr unsigned columnarAccessMode = COLUMNAR_DEFAULT_ACCESS_MODE;
 
  struct ColumnarModeXAOD
  {
    static constexpr bool isColumnarMode = true;

    static constexpr bool isXAOD = true;

    static constexpr bool isArrayMode = false;

    static constexpr bool inPlaceReplace = true;
  };
 
 
 
  struct ColumnarModeArray
  {
    static constexpr bool isColumnarMode = true;

    static constexpr bool isXAOD = false;

    static constexpr bool isArrayMode = true;

    static constexpr bool inPlaceReplace = false;
 


    using LinkIndexType = std::size_t;

    static constexpr LinkIndexType invalidLinkValue = static_cast<LinkIndexType>(-1);

    static constexpr unsigned linkKeyBits = 8;

    using LinkKeyType = std::uint8_t;

    static_assert (linkKeyBits <= 8 * sizeof(LinkKeyType), "Link key bits exceed key type size");
    static_assert (linkKeyBits < 8 * sizeof(LinkIndexType), "Link key bits exceed link type size");
    static constexpr unsigned linkIndexBits = 8 * sizeof(LinkIndexType) - linkKeyBits;
    static constexpr LinkIndexType linkIndexMask = (static_cast<LinkIndexType>(1) << linkIndexBits) - 1;

    static inline LinkKeyType getLinkKey (LinkIndexType link) {
      return link >> linkIndexBits;
    }

    static inline LinkIndexType getLinkIndex (LinkIndexType link) {
      return link & linkIndexMask;
    }

    static inline LinkIndexType mergeLinkKeyIndex (LinkIndexType key, LinkIndexType index) {
      if (key >= (static_cast<LinkIndexType>(1) << linkKeyBits))
        throw std::runtime_error ("link key too large to fit in link: " + std::to_string(key));
      if (index & ~linkIndexMask)
        throw std::runtime_error ("index too large to fit in link: " + std::to_string(index));
      return index | (key << linkIndexBits);
    }
  };
 
 
 
  struct ColumnarModeXAODArray
  {
    static constexpr bool isColumnarMode = true;

    static constexpr bool isXAOD = false;

    static constexpr bool isArrayMode = true;

    static constexpr bool inPlaceReplace = true;
 
 
    // /// Element Link Definition
    // /// =======================
    // ///
    // /// In general links are just represented by an integer index into
    // /// the target container. However, for variant links (i.e. links
    // /// pointing into one of multiple containers) we need to be able to
    // /// identify the target container. This happens by using the top
    // /// couple of bits of the index to identify the target container.
    // ///
    // /// For variant links there is also an additional column that
    // /// contains the keys for the target containers for each link, in
    // /// the order the tool defined. If there are multiple accessors for
    // /// the same variant link column, they will share the same key
    // /// column and as such need to define the variant in the same way.
    // ///
    // /// There are a couple of configurable aspects to this, like the
    // /// exact types involved, as well as the number of bits used for the
    // /// key, all of which can be configured through the columnar mode.
    // /// Beyond that there are also a couple of helper functions and
    // /// convenience definitions to avoid bit packing/unpacking code
    // /// being repeated in multiple places.

    using LinkIndexType = std::size_t;

    static constexpr LinkIndexType invalidLinkValue = static_cast<LinkIndexType>(-1);
 
    // /// the number of bits used for the key inside the link
    // static constexpr unsigned linkKeyBits = 8;

    using LinkKeyType = std::uint32_t;
 
    // /// various helper definitions
    // static_assert (linkKeyBits <= 8 * sizeof(LinkKeyType), "Link key bits exceed key type size");
    // static_assert (linkKeyBits < 8 * sizeof(LinkIndexType), "Link key bits exceed link type size");
    // static constexpr unsigned linkIndexBits = 8 * sizeof(LinkIndexType) - linkKeyBits;
    // static constexpr LinkIndexType linkIndexMask = (static_cast<LinkIndexType>(1) << linkIndexBits) - 1;
 
    // /// get the key value from a link value
    // static inline LinkKeyType getLinkKey (LinkIndexType link) {
    //   return link >> linkIndexBits;
    // }
 
    // /// get the index value from a link value
    // static inline LinkIndexType getLinkIndex (LinkIndexType link) {
    //   return link & linkIndexMask;
    // }
 
    // /// merge a key and index value into a link value
    // static inline LinkIndexType mergeLinkKeyIndex (LinkIndexType key, LinkIndexType index) {
    //   if (key >= (static_cast<LinkIndexType>(1) << linkKeyBits))
    //     throw std::runtime_error ("link key too large to fit in link: " + std::to_string(key));
    //   if (index & ~linkIndexMask)
    //     throw std::runtime_error ("index too large to fit in link: " + std::to_string(index));
    //   return index | (key << linkIndexBits);
    // }
  };
 
  template<typename Mode>
  concept ColumnarMode = Mode::isColumnarMode;
  template<typename Mode>
  concept ColumnarArrayMode = ColumnarMode<Mode> && Mode::isArrayMode;
 
 
 
#if COLUMNAR_DEFAULT_ACCESS_MODE == 0
  using ColumnarModeDefault = ColumnarModeXAOD;
#elif COLUMNAR_DEFAULT_ACCESS_MODE == 2
  using ColumnarModeDefault = ColumnarModeArray;
#elif COLUMNAR_DEFAULT_ACCESS_MODE == 100
  using ColumnarModeDefault = ColumnarModeXAODArray;
#else
  #error "COLUMNAR_DEFAULT_ACCESS_MODE must be 0, 2, or 100"
#endif
}
 
#endif