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<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<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;
    };
  }
    
  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);
    }
  };
}
}
#endif