UserInfo

Description

Generic meta-information for n-tuple (can be used out of Darwin).

Generic class to read the meta-information contained in a list. The original goal is to read and write information to store in the list TTree::GetUserInfo(), but it can be used in general.

The elements of the list may simply be reached with UserInfo::Get() and written with UserInfo::Set(). The list may contain simple types such as arithmetic types or literals as well as other lists. To reach a list, the Get and Set function simply need the list of keys to navigate through the tree structure, provided with additional arguments. Examples:

UserInfo ui;
ui.Set<bool>("one", "two", "myBool", true);
cout << ui.Get<bool>("one", "two", "myBool") << endl; // will print true
cout << ui.Get<string>("this", "will", "fail") << endl;

The whole information may be extracted in JSON, INFO, or XML format with Darwin::Tools::UserInfo::Write().

This class is as generic as can be. In certain cases, one may want to use inherit from this class to enforce a more rigid structure. One example is Darwin::Tools::MetaInfo.

#include <UserInfo.h>

Inheritance diagram for UserInfo:

Public Types
enum	Format { INFO, JSON, XML }

Public Member Functions
template<typename... Args>
TList *	List (const char *key, Args... args) const
TList *	List () const
template<class T , typename... Args>
T	Get (const char *key, Args... args) const
template<typename... Args>
bool	Find (const char *key, Args... args) const
template<class T , typename... Args>
void	Set (const char *key, Args... args) const
	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
void	ls () const

Protected Member Functions
boost::property_tree::ptree	MkPtree (TList *, Format=INFO) const

Private Member Functions
TList *	List (TList *mother, const char *key) const
template<class T >
T	Get (TList *mother, const char *key) const
template<class T , typename... Args>
T	Get (TList *mother, const char *key, Args... args) const
bool	Find (TList *mother, const char *key) const
template<typename... Args>
bool	Find (TList *mother, const char *key, Args... args) const
template<class T >
void	Set (TList *mother, const char *key, T value) const
template<class T , typename... Args>
void	Set (TList *mother, const char *key, Args... args) const
template<typename... Args>
TList *	List (TList *mother, const char *key, Args... args) const
template<class T >
T	Get (TList *mother, std::string key) const
bool	Find (TList *mother, std::string key) const
TList *	List (TList *mother, std::string key) const
void	ConvertPtree (const boost::property_tree::ptree &, const std::string &, TList *)

Private Attributes
bool	own
TList *	l

Member Enumeration Documentation

Format

enum Format

Supported serialization formats.

Enumerator
INFO	INFO format, proper to Boost Property Trees (default)
JSON	JSON format, rather common and nearly as powerful.
XML	XML format, another universal format.

                {
        INFO, 
        JSON, 
        XML 
    };

Constructor & Destructor Documentation

UserInfo() [1/5]

UserInfo

(

const char *

name = "UserInfo"

)

Constructor (starting from scratch)

    : own(true), l(new TList)
{
    l->SetName(name);
}

UserInfo() [2/5]

UserInfo

(

const boost::property_tree::ptree &

ptree

)

Constructor (starting from existing ptree)

    : own(true), l(new TList)
{
    for (const auto& [name, pt]: ptree)
        ConvertPtree(pt, name, l);
}

UserInfo() [3/5]

UserInfo

(

TList *

L

)

Constructor (starting from existing list)

    : own(false), l(L)
{
    if (L == nullptr)
        BOOST_THROW_EXCEPTION(invalid_argument("Invalid list given in argument."));
}

UserInfo() [4/5]

UserInfo

(

TTree *

t

)

Constructor (starting from TTree)

    : own(false), l(t->GetUserInfo())
{
}

UserInfo() [5/5]

UserInfo	(	TTree *	tree,
		const boost::property_tree::ptree &	ptree
	)

constructor (inserting existing ptree direcrly in a ttree)

    : own(false), l(tree->GetUserInfo())
{
    for (const auto& [name, pt]: ptree)
        ConvertPtree(pt, name, l);
}

~UserInfo()

~UserInfo

(

)

Destructor.

{
    if (!own) return;
    delete l;
}

Member Function Documentation

ConvertPtree()

void ConvertPtree ( const boost::property_tree::ptree &  pt, const std::string &  name, TList *  mother  )

private

Helper function to convert a ptree to a TList Supports making strings, bools, ints, and floats.

{
    if (pt.empty()) {
        // Value - we need to figure out the type
        auto str = pt.get_value<string>();
 
        char * end;
 
        // Bools
        if (str == "true")
            Set<bool>(mother, name.data(), true);
        else if (str == "false")
            Set<bool>(mother, name.data(), false);
 
        // Integers
        else if (int i; from_chars(str.data(), &*str.end(), i).ptr == &*str.end())
            Set<int>(mother, name.data(), i);
 
        // Floats
        else if (float f = strtof(str.data(), &end); end == &*str.end())
            Set<float>(mother, name.data(), f);
 
        // Everything else is a string
        else Set<string>(mother, name.data(), str);
    } else if (pt.count("") == pt.size()) {
        // List
        for (const auto& [_, subtree]: pt)
            ConvertPtree(subtree, name.data(), mother);
    } else {
        // Subtree
        auto child = List(mother, name);
        for (const auto& [subname, subtree]: pt)
            ConvertPtree(subtree, subname.c_str(), child);
    }
}

Empty()

bool Empty

(

)

const

Check if list is empty.

{
    return l->GetSize() == 0;
}

Find() [1/4]

bool Find ( const char *  key, Args...  args  ) const

inline

Generic finder.

    {
        return Find(l, key, args...);
    }

Find() [2/4]

bool Find ( TList *  mother, const char *  key  ) const

inlineprivate

Recursive finder.

    {
        TObject * obj = mother->FindObject(key);
        return (obj != nullptr);
    }

Find() [3/4]

bool Find ( TList *  mother, const char *  key, Args...  args  ) const

inlineprivate

Recursive finder.

    {
        if (!Find(mother, key)) return false;
        TList * daughter = List(mother, key);
        if (daughter->GetSize() > 0)
            return Find(daughter, args...);
        else return false;
    }

Find() [4/4]

bool Find ( TList *  mother, std::string  key  ) const

inlineprivate

finder with string

Get() [1/4]

T Get ( const char *  key, Args...  args  ) const

inline

Generic getter.

    {
        return Get<T>(l, key, args...);
    }

Get() [2/4]

T Get ( TList *  mother, const char *  key  ) const

inlineprivate

Final getter. The behaviour for arithmetic types and for literal (default) is slightly different, since literals don't really have a key. Literals are always contained in a list, and the last element of the list is returned.

    {
        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;
        }
    }

Get() [3/4]

T Get ( TList *  mother, const char *  key, Args...  args  ) const

inlineprivate

Recursive getter.

    {
        TList * daughter = List(mother, key);
        return Get<T>(daughter, args...);
    }

Get() [4/4]

T Get ( TList *  mother, std::string  key  ) const

inlineprivate

value getter with string

List() [1/5]

TList* List ( ) const

inline

Access directly to main list.

    {
        return l;
    }

List() [2/5]

TList* List ( const char *  key, Args...  args  ) const

inline

Access directly a sublist.

    {
        return List(l, key, args...);
    }

List() [3/5]

TList * List ( TList *  mother, const char *  key  ) const

private

Accest do daughter list from a mother list.

{
    TObject * obj = mother->FindObject(key);
    if (obj == nullptr) {
        auto daughter = static_cast<TList *>(obj);
        daughter = new TList;
        daughter->SetName(key);
        mother->Add(daughter);
        return daughter;
    }
    else {
        TString classname = obj->ClassName();
        if (classname != "TList")
            BOOST_THROW_EXCEPTION(invalid_argument(key));
        auto daughter = dynamic_cast<TList *>(obj);
        return daughter;
    }
}

List() [4/5]

TList* List ( TList *  mother, const char *  key, Args...  args  ) const

inlineprivate

Access a sublist.

    {
        TList * daughter = List(mother, key);
        return List(daughter, args...);
    }

List() [5/5]

TList* List ( TList *  mother, std::string  key  ) const

inlineprivate

list getter with string

ls()

void ls ( ) const

inline

Prints the content of the TList

{ if (l != nullptr) l->ls(); }

MkPtree() [1/2]

boost::property_tree::ptree MkPtree ( Format  format = INFO ) const

inline

Write main TList to Boost Property Tree.

Returns

content of full TList in Property Tree format

Parameters

format

format of output file

                                        { return MkPtree(l, format); }

MkPtree() [2/2]

pt::ptree MkPtree ( TList *  list, Format  format = INFO  ) const

protected

Write TList to Boost Property Tree. Calls itself recursively. Internally, it uses Boost Preprocessor macros to loop over types.

Returns

content of TList given in argument in Property Tree format

Parameters

list	list to write to `ptree`
format	format of output file (e.g. XML cannot handle empty keys)

{
    assert(list);
    pt::ptree tree; // this tree will contain the list
    for (const auto& obj: *list) {
        const char * key = obj->GetName();
        const TString classname = obj->ClassName();
        if (classname == "TList") {
            auto sublist = dynamic_cast<TList *>(obj);
            pt::ptree child = MkPtree(sublist, format);
            tree.add_child(key, child);
        }
        else if (classname == "TObjString") {
            auto objs = dynamic_cast<TObjString *>(obj);
            const char * value = objs->GetString().Data();
            if (list->GetSize() == 1) 
                tree.put<const char *>("", value);
            else switch (format) {
                case XML: tree.add("item", value);
                          break;
                case INFO:
                case JSON:
                    {
                         pt::ptree node;
                         node.put("", value);
                         tree.push_back(make_pair("", node));
                    }
            }
        }
#define ARITHMETIC_TYPES (bool)(char)(signed char)(short)(short int)(int)(long int)(long long int)(unsigned char)(unsigned short)(unsigned short int)(unsigned)(unsigned int)(unsigned long)(unsigned long int)(unsigned long long)(unsigned long long int)(float)(double)(long double)
#define ELSE_IF_TPARAM(r, data, TYPE) \
        else if (classname == "TParameter<" BOOST_PP_STRINGIZE(TYPE) ">") { \
            auto param = dynamic_cast<TParameter<TYPE>*>(obj); \
            tree.add<TYPE>(key, param->GetVal()); \
        }
        BOOST_PP_SEQ_FOR_EACH(ELSE_IF_TPARAM, _, ARITHMETIC_TYPES)
#undef ARITHMETIC_TYPES
#undef ELSE_IF_TPARAM
        else 
            cerr << orange << "Warning: " << classname << " is not handled by " << __func__ << ", therefore `" << key << "` will ignored.\n" << def;
    }
    return tree;
}

Set() [1/3]

void Set ( const char *  key, Args...  args  ) const

inline

Generic setter. The key is the name of the first sublist (if any), or to the element directly. An extra argument (implicitly in the variadic argument) contains the value.

    {
        Set<T>(l, key, args...);
    }

Set() [2/3]

void Set ( TList *  mother, const char *  key, Args...  args  ) const

inlineprivate

Recursive setter.

    {
        TList * daughter = List(mother, key);
        Set<T>(daughter, args...);
    }

Set() [3/3]

void Set ( TList *  mother, const char *  key, T  value  ) const

inlineprivate

(Re)sets elements of a given list.

Only arithmetic types have a key and a value. Literals only have identical key and value.

    {
        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 {
            TList * daughter = List(mother, key);
            TString str(value);
            auto objs = new TObjString(str);
            daughter->Add(objs);
        }
    }

Write() [1/3]

void Write

(

)

const

Write TList to TFile in ROOT format.

{
    TString name = l->GetName();
    if (name.IsNull()) name = "UserInfo";
    l->Write(name, TList::kSingleKey);
}

Write() [2/3]

pt::ptree Write

(

const std::filesystem::path &

p

)

const

Write to file with Boost. Calls MkPtree to write sublists.

Returns

content of full TList in Property Tree format

Parameters

p	path to output

{
    auto type = INFO;
    if (p.extension() == ".json")
        type = JSON;
    else if (p.extension() == ".xml")
        type = XML;
 
    ofstream stream(p);
    return Write(stream, type);
}

Write() [3/3]

pt::ptree Write	(	std::ostream &	out,
		Format	format = INFO
	)		const

Write to stream with Boost. Calls MkPtree to write sublists.

Returns

content of full TList in Property Tree format

Parameters

out	output stream
format	format of output

{
    pt::ptree tree = MkPtree(format);
 
    switch (format) {
        case JSON:
        {
            stringstream ss;
            write_json(ss, tree);
            string str = ss.str();
            // by default, everything is a string
            // -> we remove quotation marks for numerics and booleans
            regex numbers("\\\"([0-9]+\\.{0,1}[0-9]*)\\\""), // note: no support for hex
                  booleans("\\\"(true|false)\\\"");
            str = regex_replace(str, numbers, "$1");
            str = regex_replace(str, booleans, "$1");
            al::replace_all(str, "\\/", "/");
            out << str;
            break;
        }
        case XML :
        {
            pt::ptree userinfo;
            userinfo.put_child("userinfo", tree); // there must be exactly one global key
            pt::xml_writer_settings<string> settings(' ', 2); // indentation with 2 spaces
            write_xml(out, userinfo, settings);
            break;
        }
        case INFO:
        {
            stringstream ss;
            write_info(ss, tree);
            string str = ss.str();
            al::erase_all(str, "\"\"");
            out << str;
        }
    }
 
    return tree;
}

Member Data Documentation

l

TList* l

private

main list (typically from TTree::GetUserInfo())

own

bool own

private

---

The documentation for this class was generated from the following files:

• /builds/Proto/Darwin/interface/UserInfo.h
• /builds/Proto/Darwin/src/UserInfo.cc