Table.h

Go to the documentation of this file.

#ifndef FWCore_SOA_Table_h
#define FWCore_SOA_Table_h
// -*- C++ -*-
//
// Package:     FWCore/SOA
// Class  :     Table
//
//
// Original Author:  Chris Jones
//         Created:  Thu, 24 Aug 2017 16:18:05 GMT
//

// system include files
#include <memory>
#include <tuple>
#include <array>

// user include files
#include "FWCore/SOA/interface/TableItr.h"
#include "FWCore/SOA/interface/tablehelpers.h"
#include "FWCore/SOA/interface/ColumnFillers.h"
#include "FWCore/SOA/interface/ColumnValues.h"
#include "FWCore/SOA/interface/RowView.h"

//The following is needed for edm::Wrapper
#include "FWCore/SOA/interface/TableExaminer.h"

// forward declarations

namespace edm {
  namespace soa {

    template <typename... Args>
    class Table {
    public:
      static constexpr const unsigned int kNColumns = sizeof...(Args);
      using Layout = std::tuple<Args...>;
      using const_iterator = ConstTableItr<Args...>;
      using iterator = TableItr<Args...>;

      template <typename T, typename... CArgs>
      Table(T const& iContainer, CArgs... iArgs) : m_size(iContainer.size()) {
        if constexpr (sizeof...(CArgs) == 0) {
          CtrFillerFromAOS::fill(m_values, iContainer);
        } else {
          CtrFillerFromContainers::fill(m_values, iContainer, std::forward<CArgs>(iArgs)...);
        }
      }

      template <typename T, typename... CArgs>
      Table(T const& iContainer, ColumnFillers<CArgs...> iFiller) {
        m_size = iContainer.size();
        CtrFillerFromAOS::fillUsingFiller(iFiller, m_values, iContainer);
      }

      Table(Table<Args...> const& iOther) : m_size(iOther.m_size), m_values{{nullptr}} {
        copyFromToWithResizeAll(m_size, iOther.m_values, m_values, std::make_index_sequence<sizeof...(Args)>{});
      }

      Table(Table<Args...>&& iOther) : m_size(0), m_values{{nullptr}} {
        std::swap(m_size, iOther.m_size);
        std::swap(m_values, iOther.m_values);
      }

      Table() : m_size(0) {}

      ~Table() { dtr<0>(m_values); }

      Table<Args...>& operator=(Table<Args...>&& iOther) {
        Table<Args...> cp(std::move(iOther));
        std::swap(m_size, cp.m_size);
        std::swap(m_values, cp.m_values);
        return *this;
      }
      Table<Args...>& operator=(Table<Args...> const& iOther) { return operator=(Table<Args...>(iOther)); }

      unsigned int size() const { return m_size; }

      void resize(unsigned int iNewSize) {
        if (m_size == iNewSize) {
          return;
        }
        resizeFromTo<0>(m_size, iNewSize, m_values);
        if (m_size < iNewSize) {
          //initialize the extra values
          resetStartingAt<0>(m_size, iNewSize, m_values);
        }
        m_size = iNewSize;
      }

      template <typename U>
      typename U::type const& get(size_t iRow) const {
        return *(static_cast<typename U::type const*>(columnAddress<U>()) + iRow);
      }
      template <typename U>
      typename U::type& get(size_t iRow) {
        return *(static_cast<typename U::type*>(columnAddress<U>()) + iRow);
      }

      template <typename U>
      ColumnValues<typename U::type> column() const {
        return ColumnValues<typename U::type>{static_cast<typename U::type*>(columnAddress<U>()), m_size};
      }
      template <typename U>
      MutableColumnValues<typename U::type> column() {
        return MutableColumnValues<typename U::type>{static_cast<typename U::type*>(columnAddress<U>()), m_size};
      }

      RowView<Args...> row(size_t iRow) const { return *(begin() + iRow); }
      MutableRowView<Args...> row(size_t iRow) { return *(begin() + iRow); }

      const_iterator begin() const {
        std::array<void const*, sizeof...(Args)> t;
        for (size_t i = 0; i < t.size(); ++i) {
          t[i] = m_values[i];
        }
        return const_iterator{t};
      }
      const_iterator end() const {
        std::array<void const*, sizeof...(Args)> t;
        for (size_t i = 0; i < t.size(); ++i) {
          t[i] = m_values[i];
        }
        return const_iterator{t, size()};
      }

      iterator begin() { return iterator{m_values}; }
      iterator end() { return iterator{m_values, size()}; }

      template <typename U>
      void const* columnAddressWorkaround(U const*) const {
        return columnAddress<U>();
      }

      void const* columnAddressByIndex(unsigned int iIndex) const { return m_values[iIndex]; }

    private:
      // Member data
      unsigned int m_size = 0;
      std::array<void*, sizeof...(Args)> m_values = {{nullptr}};  

      template <typename U>
      void const* columnAddress() const {
        return m_values[impl::GetIndex<0, U, Layout>::index];
      }

      template <typename U>
      void* columnAddress() {
        return m_values[impl::GetIndex<0, U, Layout>::index];
      }

      //Recursive destructor handling
      template <int I>
      static void dtr(std::array<void*, sizeof...(Args)>& iArray) {
        if constexpr (I < sizeof...(Args)) {
          using Type = typename std::tuple_element<I, Layout>::type::type;
          delete[] static_cast<Type*>(iArray[I]);
          dtr<I + 1>(iArray);
        }
      }

      //Construct the Table using a container per column
      struct CtrFillerFromContainers {
        template <typename T, typename... U>
        static size_t fill(std::array<void*, sizeof...(Args)>& oValues, T const& iContainer, U... iArgs) {
          static_assert(sizeof...(Args) == sizeof...(U) + 1, "Wrong number of arguments passed to Table constructor");
          ctrFiller<0>(oValues, iContainer.size(), iContainer, std::forward<U>(iArgs)...);
          return iContainer.size();
        }

      private:
        template <int I, typename T, typename... U>
        static void ctrFiller(std::array<void*, sizeof...(Args)>& oValues, size_t iSize, T const& iContainer, U... iU) {
          assert(iContainer.size() == iSize);
          using Type = typename std::tuple_element<I, Layout>::type::type;
          Type* temp = new Type[iSize];
          unsigned int index = 0;
          for (auto const& v : iContainer) {
            temp[index] = v;
            ++index;
          }
          oValues[I] = temp;

          ctrFiller<I + 1>(oValues, iSize, std::forward<U>(iU)...);
        }

        template <int I>
        static void ctrFiller(std::array<void*, sizeof...(Args)>&, size_t) {}
      };

      //Construct the Table using one container with each entry representing a row
      struct CtrFillerFromAOS {
        template <typename T>
        static size_t fill(std::array<void*, sizeof...(Args)>& oValues, T const& iContainer) {
          presize<0>(oValues, iContainer.size());
          unsigned index = 0;
          for (auto&& item : iContainer) {
            fillElement<0>(item, index, oValues);
            ++index;
          }
          return iContainer.size();
        }

        template <typename T, typename F>
        static size_t fillUsingFiller(F& iFiller, std::array<void*, sizeof...(Args)>& oValues, T const& iContainer) {
          presize<0>(oValues, iContainer.size());
          unsigned index = 0;
          for (auto&& item : iContainer) {
            fillElementUsingFiller<0>(iFiller, item, index, oValues);
            ++index;
          }
          return iContainer.size();
        }

      private:
        template <int I>
        static void presize(std::array<void*, sizeof...(Args)>& oValues, size_t iSize) {
          if constexpr (I < sizeof...(Args)) {
            using Layout = std::tuple<Args...>;
            using Type = typename std::tuple_element<I, Layout>::type::type;
            oValues[I] = new Type[iSize];
            presize<I + 1>(oValues, iSize);
          }
        }

        template <int I, typename E>
        static void fillElement(E const& iItem, size_t iIndex, std::array<void*, sizeof...(Args)>& oValues) {
          if constexpr (I < sizeof...(Args)) {
            using Layout = std::tuple<Args...>;
            using ColumnType = typename std::tuple_element<I, Layout>::type;
            using Type = typename ColumnType::type;
            Type* pElement = static_cast<Type*>(oValues[I]) + iIndex;
            *pElement = value_for_column(iItem, static_cast<ColumnType*>(nullptr));
            fillElement<I + 1>(iItem, iIndex, oValues);
          }
        }

        template <int I, typename E, typename F>
        static void fillElementUsingFiller(F& iFiller,
                                           E const& iItem,
                                           size_t iIndex,
                                           std::array<void*, sizeof...(Args)>& oValues) {
          if constexpr (I < sizeof...(Args)) {
            using Layout = std::tuple<Args...>;
            using ColumnType = typename std::tuple_element<I, Layout>::type;
            using Type = typename ColumnType::type;
            Type* pElement = static_cast<Type*>(oValues[I]) + iIndex;
            *pElement = iFiller.value(iItem, static_cast<ColumnType*>(nullptr));
            fillElementUsingFiller<I + 1>(iFiller, iItem, iIndex, oValues);
          }
        }
      };

      template <size_t... I>
      static void copyFromToWithResizeAll(size_t iNElements,
                                          std::array<void*, sizeof...(Args)> const& iFrom,
                                          std::array<void*, sizeof...(Args)>& oTo,
                                          std::index_sequence<I...>) {
        (copyFromToWithResize<I>(iNElements, iFrom, oTo), ...);
      }

      template <int I>
      static void copyFromToWithResize(size_t iNElements,
                                       std::array<void*, sizeof...(Args)> const& iFrom,
                                       std::array<void*, sizeof...(Args)>& oTo) {
        using Layout = std::tuple<Args...>;
        using Type = typename std::tuple_element<I, Layout>::type::type;
        Type* oldPtr = static_cast<Type*>(oTo[I]);
        Type* ptr = new Type[iNElements];
        oTo[I] = ptr;
        std::copy(static_cast<Type const*>(iFrom[I]), static_cast<Type const*>(iFrom[I]) + iNElements, ptr);
        delete[] oldPtr;
      }

      template <int I>
      static void resizeFromTo(size_t iOldSize, size_t iNewSize, std::array<void*, sizeof...(Args)>& ioArray) {
        if constexpr (I < sizeof...(Args)) {
          using Layout = std::tuple<Args...>;
          using Type = typename std::tuple_element<I, Layout>::type::type;
          Type* oldPtr = static_cast<Type*>(ioArray[I]);
          auto ptr = new Type[iNewSize];
          auto nToCopy = std::min(iOldSize, iNewSize);
          std::copy(static_cast<Type const*>(ioArray[I]), static_cast<Type const*>(ioArray[I]) + nToCopy, ptr);
          resizeFromTo<I + 1>(iOldSize, iNewSize, ioArray);

          delete[] oldPtr;
          ioArray[I] = ptr;
        }
      }

      template <int I>
      static void resetStartingAt(size_t iStartIndex, size_t iEndIndex, std::array<void*, sizeof...(Args)>& ioArray) {
        if constexpr (I < sizeof...(Args)) {
          using Layout = std::tuple<Args...>;
          using Type = typename std::tuple_element<I, Layout>::type::type;
          auto ptr = static_cast<Type*>(ioArray[I]);
          auto temp = Type{};
          std::fill(ptr + iStartIndex, ptr + iEndIndex, temp);
          resetStartingAt<I + 1>(iStartIndex, iEndIndex, ioArray);
        }
      }
    };

    /* Table Type Manipulation */
    template <typename T1, typename T2>
    struct AddColumns;
    template <typename... T1, typename... T2>
    struct AddColumns<Table<T1...>, std::tuple<T2...>> {
      using type = Table<T1..., T2...>;
    };

    template <typename T1, typename T2>
    using AddColumns_t = typename AddColumns<T1, T2>::type;

    namespace impl {
      template <typename LHS, typename E, typename RHS>
      struct RemoveColumnCheck;
      template <typename LHS, typename E, typename T, typename... U>
      struct RemoveColumnCheck<LHS, E, std::tuple<T, U...>> {
        using type = typename std::conditional<
            std::is_same<E, T>::value,
            typename AddColumns<LHS, std::tuple<U...>>::type,
            typename RemoveColumnCheck<typename AddColumns<LHS, std::tuple<T>>::type, E, std::tuple<U...>>::type>::type;
      };

      template <typename LHS, typename E>
      struct RemoveColumnCheck<LHS, E, std::tuple<>> {
        using type = LHS;
      };
    }  // namespace impl

    template <typename TABLE, typename E>
    struct RemoveColumn {
      using type = typename impl::RemoveColumnCheck<Table<>, E, typename TABLE::Layout>::type;
    };

    template <typename TABLE, typename E>
    using RemoveColumn_t = typename RemoveColumn<TABLE, E>::type;

    //This is used by edm::Wrapper
    template <typename T>
    struct MakeTableExaminer;

    template <typename... Args>
    struct MakeTableExaminer<Table<Args...>> {
      static std::unique_ptr<TableExaminerBase> make(const Table<Args...>* iTable) {
        return std::make_unique<TableExaminer<Table<Args...>>>(iTable);
      }
    };
  }  // namespace soa
}  // namespace edm
#endif