SysResultPtr.h

Go to the documentation of this file.

#ifndef RDFAnalysis_SysResultPtr_H
#define RDFAnalysis_SysResultPtr_H

// Package includes
#include "RDFAnalysis/ResultWrapper.h"

namespace RDFAnalysis {
  template <typename T>
    class SysResultPtr {
      public:
        SysResultPtr(const std::string& nominalName) :
          m_nominal(nominalName) {}

        template <typename U,
                 typename = std::enable_if_t<std::is_base_of<T, U>{} || std::is_same<T, U>{}, void>>
          SysResultPtr(
              const std::string& nominalName,
              const std::map<std::string, ROOT::RDF::RResultPtr<U>>& resultMap) :
            m_nominal(nominalName)
          {
            for (const auto& p : resultMap)
              addResult(p.first, p.second);
          }

        auto begin() { return m_wrappers.begin(); }

        auto begin() const { return m_wrappers.begin(); }

        auto end() { return m_wrappers.end(); }

        auto end() const { return m_wrappers.end(); }

        std::size_t size() const { return m_wrappers.size(); }

        void setMap(const std::map<std::string, ResultWrapper<T>>& newMap) { m_wrappers = newMap; }

        void reset() { m_wrappers.clear(); }

        T* get(const std::string& syst) 
        {
          auto itr = m_wrappers.find(syst);
          return itr == m_wrappers.end()
            ? m_wrappers.at(m_nominal).get()
            : itr->second.get();
        }

        // TODO (maybe) - make it impossible to overwrite a result with this
        // method, or rather to make it throw an error if you try...
        bool addResult(
            const std::string& systematic,
            const ResultWrapper<T>& result)
        {
          return m_wrappers.insert(std::make_pair(systematic, result) ).second;
        }

        template <typename U,
                  typename = std::enable_if_t<std::is_base_of<T, U>{}, void>
                 >
          SysResultPtr(const SysResultPtr<U>& other) :
            m_nominal(other.m_nominal)
          {
            for (const auto& p : other)
              m_wrappers.insert(std::make_pair(
                    p.first, ResultWrapper<T>(p.second) ) );
          }

        operator bool() const { return m_wrappers.size() != 0; }

      private:
        template <typename U>
          friend class SysResultPtr;
        std::string m_nominal;
        std::map<std::string, ResultWrapper<T>> m_wrappers;
    };
}
#endif //> !RDFAnalysis_SysResultPtr_H