UserInfo.h

Go to the documentation of this file.

#ifndef DARWIN_USERINFO_H
#define DARWIN_USERINFO_H
 
#include <cassert>
 
#include <type_traits>
#include <iostream>
#include <filesystem>
#include <typeinfo>
#include <stdexcept>
#include <string>
#include <functional>
#include <sstream>
 
#include <TList.h>
#include <TString.h>
#include <TParameter.h>
#include <TObjString.h>
 
#include <boost/property_tree/ptree.hpp>      
#include <boost/exception/all.hpp>
 
#include "colours.h"
 
class TTree;
 
namespace Darwin::Tools {
 
class UserInfo {
public:
    enum Format {
        INFO, 
        JSON, 
        XML 
    };
 
private:
    bool own;
    TList * l; 
 
    TList * List (TList * mother, const char * key) const;
 
    template<class T> T Get (TList * mother, const char * key) const
    {
        if constexpr (std::is_arithmetic_v<T>) {
            TObject * obj = mother->FindObject(key);
            auto parameter = dynamic_cast<TParameter<T>*>(obj);
            if (parameter == nullptr)
                BOOST_THROW_EXCEPTION(std::invalid_argument(
                        Form("No `TParameter` with name '%s' could be found in the `TList` '%s'.", key, mother->GetName())));
            return parameter->GetVal();
        }
        else {
            TList * daughter = List(mother, key);
            TIter next(daughter->begin());
            auto objs = dynamic_cast<TObjString*>(daughter->Last());
            if (daughter->GetSize() == 0 || objs == nullptr)
                BOOST_THROW_EXCEPTION(std::invalid_argument(
                        Form("No literal with name '%s' was found in the `TList` '%s'.", key, mother->GetName())));
            T literal = objs->GetString().Data();
            return literal;
        }
    }
 
    template<class T, typename... Args> T Get (TList * mother, const char * key, Args... args) const
    {
        TList * daughter = List(mother, key);
        return Get<T>(daughter, args...);
    }
 
    bool Find (TList * mother, const char * key) const
    {
        CheckKey(key);
        TObject * obj = mother->FindObject(key);
        return (obj != nullptr);
    }
 
    template<typename... Args> bool Find (TList * mother, const char * key, Args... args) const
    {
        if (!Find(mother, key)) return false;
        TList * daughter = List(mother, key);
        if (daughter->GetSize() > 0)
            return Find(daughter, args...);
        else return false;
    }
 
    void CheckKey (const char * key) const
    {
        if (TString(key).Length() == 0)
            BOOST_THROW_EXCEPTION( std::invalid_argument("Empty keys are invalid") );
    }
 
    template<class T> void Set (TList * mother, const char * key, T value) const
    {
        CheckKey(key);
 
        if constexpr (std::is_arithmetic_v<T>) {
            TObject * obj = mother->FindObject(key);
            if (obj) {
                auto parameter = dynamic_cast<TParameter<T>*>(obj);
                if (parameter == nullptr)
                    BOOST_THROW_EXCEPTION(std::invalid_argument(
                                Form("No `TParameter` with name '%s' and typeid '%s' was found in the `TList` '%s'.",
                                                key, typeid(T).name(), mother->GetName())));
                parameter->SetVal(value);
            }
            else {
                auto parameter = new TParameter<T>(key, value, 'l');
                mother->Add(parameter);
            }
        }
        else {
            TString str(value);
            TList * daughter = List(mother, key);
            if (str.Length() >= 0) {
                auto objs = new TObjString(str);
                daughter->Add(objs);
            }
        }
    }
 
    template<class T, typename... Args> void Set (TList * mother, const char * key, Args... args) const
    {
        CheckKey(key);
        TList * daughter = List(mother, key);
        Set<T>(daughter, args...);
    }
 
    template<typename... Args> TList * List (TList * mother, const char * key, Args... args) const
    {
        TList * daughter = List(mother, key);
        return List(daughter, args...);
    }
 
    template<class T>
    T       Get  (TList * mother, std::string key) const { return Get<T>(mother, key.c_str()); } 
    bool    Find (TList * mother, std::string key) const { return Find  (mother, key.c_str()); } 
    TList * List (TList * mother, std::string key) const { return List  (mother, key.c_str()); } 
 
protected:
 
    void ConvertPtree (const boost::property_tree::ptree&, const std::string&, TList*);
    
    boost::property_tree::ptree MkPtree (TList *, 
                 Format = INFO 
                 ) const;
 
    boost::property_tree::ptree Write (const boost::property_tree::ptree&,
                                       std::ostream&, 
                                       Format = INFO  
                                       ) const;
 
public:
    template<typename... Args> TList * List (const char * key, Args... args) const
    {
        return List(l, key, args...);
    }
 
    TList * List () const
    {
        return l;
    }
 
    template<class T, typename... Args> T Get (const char * key, Args... args) const
    {
        return Get<T>(l, key, args...);
    }
 
    template<typename... Args> bool Find (const char * key, Args... args) const
    {
        return Find(l, key, args...);
    }
 
    template<class T, typename... Args> void Set (const char * key, Args... args) const
    {
        Set<T>(l, key, args...);
    }
 
    UserInfo (const char * = "UserInfo"); 
    UserInfo (const boost::property_tree::ptree&); 
    UserInfo (TList *); 
    UserInfo (TTree *); 
    UserInfo (TTree *, const boost::property_tree::ptree&); 
    ~UserInfo (); 
 
    void Write () const; 
    bool Empty () const; 
 
    boost::property_tree::ptree Write (std::ostream&, 
                                       Format = INFO  
                                       ) const;
 
    boost::property_tree::ptree Write (const std::filesystem::path& 
                                       ) const;
 
    boost::property_tree::ptree MkPtree (Format format = INFO 
                                ) const { return MkPtree(l, format); }
 
    void ls () const { if (l != nullptr) l->ls(); }
};
 
} // end of namespace
 
template<> struct std::hash<boost::property_tree::ptree> {
    std::size_t operator() (boost::property_tree::ptree const&) const noexcept;
};
 
template<> struct std::hash<Darwin::Tools::UserInfo> {
    std::size_t operator() (Darwin::Tools::UserInfo const&) const noexcept;
};
 
template<> struct std::hash<TTree *> {
    std::size_t operator() (TTree * const&) const noexcept;
};
 
#endif