JDataFrame.hh

Go to the documentation of this file.

#ifndef __JROOT__JDATAFRAME__
#define __JROOT__JDATAFRAME__

#include <string>
#include <memory>
#include <map>
#include <vector>

#include "TROOT.h"
#include "TClass.h"
#include "TDataMember.h"
#include "ROOT/RDF/RInterfaceBase.hxx"
#include "ROOT/RDataFrame.hxx"

#include "JLang/JSingleton.hh"
#include "JLang/JException.hh"
#include "JTools/JRange.hh"


/**
 * \author mdejong
 */

namespace JROOT {}
namespace JPP { using namespace JROOT; }

namespace JROOT {

  using JLANG::JSingleton;
  using JLANG::JException;


  /**
   * Auxiliary class for parsing data from ROOT data frame.
   */
  class JDataFrame {
  public:
    /**
     * Type definition for range.
     */
    typedef JTOOLS::JRange<unsigned int>  range_type;
    
  private:
    /**
     * Interface for output.
     */
    struct JOutput {
      /**
       * Virtual destructor.
       */
      virtual ~JOutput()
      {}


      /**
       * Get address.
       *
       * \param  i           index
       * \return             address
       */
      virtual char* getAddress(const size_t i) = 0;


      /**
       * Put value at given index.
       *
       * \param  i           index
       * \param  value       value
       */
      template<class T>
      void put(const size_t i, const T& value)
      {
        * ((T*) getAddress(i)) = value;
      }
    };


    /**
     * Interface for parsing data from ROOT data frame to output.
     */
    struct JParser {
      /**
       * Virtual destructor.
       */
      virtual ~JParser()
      {}


      /**
       * Parse data.
       *
       * \param  in          input
       * \param  column      column name
       * \param  range       range
       * \param  out         output
       * \return             number of entries parsed
       */
      virtual size_t parse(ROOT::RDataFrame& in, const char* const column, const range_type& range, JOutput& out) const = 0;
    };


    /**
     * Template implementation for parsing data from ROOT data frame to output.
     */
    template<class T>
    struct JParser_t :
      public JParser
    {
      /**
       * Parse data.
       *
       * \param  in          input
       * \param  column      column name
       * \param  range       range
       * \param  out         output
       * \return             number of entries parsed
       */
      virtual size_t parse(ROOT::RDataFrame& in, const char* const column, const range_type& range, JOutput& out) const override
      {
        size_t i = 0;
        
        in.Range(range.getLowerLimit(), range.getUpperLimit()).Foreach([&](T value) { out.put(i++, value); }, { column });

        return i;
      }
    };

  public:
    /**
     * Dictionary for parsing data from ROOT data frame to output.
     */
    struct JDictionary :
      public std::map<std::string, std::unique_ptr<JParser> >,
      public JSingleton<JDictionary>
    {
      JDictionary()
      {
        add<bool>();
        add<char>();
        add<unsigned char>();
        add<short>();
        add<unsigned short>();
        add<int>();
        add<unsigned int>();
        add<long int>();
        add<unsigned long int>();
        add<long long int>();
        add<unsigned long long int>();
        add<float>();
        add<double>();
        add<std::string>();
      }


      /**
       * Get typename for given template class.
       *
       * This method uses the TDictionary class to get the name of the given class.
       *
       * \return               type name
       */
      template<class T>
      static const char* getTypename()
      {
        const TDictionary* pDictionary = TDictionary::GetDictionary(typeid(T));

        if (pDictionary != NULL)
          return pDictionary->GetName();
        else
          THROW(JException, "Data type not implemented.");
      }


      /**
       * Add parser for given class to dictionary.
       */
      template<class T>
      void add()
      {
        (*this)[getTypename<T>()].reset(new JDataFrame::JParser_t<T>());
      }
    };


    /**
     * Auxiliary buffer for parsing data from ROOT data frame.
     */
    template<class T>
    struct JBuffer :
      public std::vector<T>
    {
      /**
       * Default constructor.
       */
      JBuffer() :
        cs(TClass::GetClass<T>())
      {
        if (!cs) {
          THROW(JException, "Data type not defined via ROOT TClass.");
        }
      }


      /**
       * Parse data.
       *
       * \param  in          input
       * \param  range       range
       * \return             number of entries parsed
       */
      size_t operator()(ROOT::RDataFrame& in, const range_type& range)
      {
        size_t N = range.getUpperLimit() - range.getLowerLimit();

        if (N != 0) {

          this->resize(N);

          for (const std::string& column : in.GetColumnNames()) {

            TDataMember* ps = cs->GetDataMember(column.c_str());

            if (ps != NULL && JDictionary::getInstance().count(ps->GetTypeName()) != 0) {

              JOutput_t out(*this, ps->GetOffset());

              N = std::min(N, JDictionary::getInstance()[ps->GetTypeName()]->parse(in, column.c_str(), range, out));

            } else {

              THROW(JException, "Data type not implemented for column " << column);
            }
          }
        }

        return N;
      }
      
    private:

      TClass* cs = NULL;

      /**
       * Template implementation for output.
       */
      struct JOutput_t :
        public JDataFrame::JOutput
      {
        /**
         * Constructor
         *
         * \param  data        data
         * \param  offset      offset
         */
        JOutput_t(std::vector<T>& data, const int offset) :
          data(data),
          offset(offset)
        {}
              

        /**
         * Get address.
         *
         * \param  i           index
         * \return             address
         */
        virtual char* getAddress(const size_t i) override
        {
          return ((char*) &(data[i])) + offset;
        }

      private:
        std::vector<T>& data;
        const int       offset;
      };
    };
  };
}

#endif