TRestReflector.h

#ifndef RestTools_REST_Reflection
#define RestTools_REST_Reflection
 
#include <TFormula.h>
#include <TVector2.h>
#include <TVector3.h>
#include <stdio.h>
#include <stdlib.h>
 
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <sstream>
 
#include "Strlen.h"
#include "TBuffer.h"
#include "TBufferFile.h"
#include "TClass.h"
#include "TClassEdit.h"
#include "TDataMember.h"
#include "TDataType.h"
#include "TRestStringHelper.h"
#include "TStreamerElement.h"
#include "TVirtualStreamerInfo.h"
 
class TRestEventProcess;
 
namespace REST_Reflection {
 
struct DataType_Info {
    char name[20]{'u', 'n', 'k', 'n', 'o', 'w', 'n', 0};
    Int_t size = 0;
    const std::type_info* typeinfo = 0;
 
    DataType_Info() {}
 
    DataType_Info(std::string name) {
        switch (ToHash(name)) {
            case ToHash("char"):
                typeinfo = &typeid(char);
                size = sizeof(char);
                break;
            case ToHash("short"):
                typeinfo = &typeid(short);
                size = sizeof(short);
                break;
            case ToHash("int"):
                typeinfo = &typeid(int);
                size = sizeof(int);
                break;
            case ToHash("long"):
                typeinfo = &typeid(long);
                size = sizeof(long);
                break;
            case ToHash("long int"):
                typeinfo = &typeid(long int);
                size = sizeof(long int);
                break;
            case ToHash("long long"):
                typeinfo = &typeid(long long);
                size = sizeof(long long);
                break;
            case ToHash("bool"):
                typeinfo = &typeid(bool);
                size = sizeof(bool);
                break;
            case ToHash("float"):
                typeinfo = &typeid(float);
                size = sizeof(float);
                break;
            case ToHash("double"):
                typeinfo = &typeid(double);
                size = sizeof(double);
                break;
            case ToHash("long double"):
                typeinfo = &typeid(long double);
                size = sizeof(long double);
                break;
            case ToHash("unsigned char"):
                typeinfo = &typeid(unsigned char);
                size = sizeof(unsigned char);
                break;
            case ToHash("unsigned short"):
                typeinfo = &typeid(unsigned short);
                size = sizeof(unsigned short);
                break;
            case ToHash("unsigned int"):
                typeinfo = &typeid(unsigned int);
                size = sizeof(unsigned int);
                break;
            case ToHash("unsigned long"):
                typeinfo = &typeid(unsigned long);
                size = sizeof(unsigned long);
                break;
            case ToHash("unsigned long long"):
                typeinfo = &typeid(unsigned long long);
                size = sizeof(unsigned long long);
                break;
            case ToHash("unsigned long int"):
                typeinfo = &typeid(unsigned long int);
                size = sizeof(unsigned long int);
                break;
            case ToHash("char*"):
                typeinfo = &typeid(char*);
                size = sizeof(char*);
                break;
            case ToHash("size_t"):
                typeinfo = &typeid(size_t);
                size = sizeof(char*);
                break;
            // we also add some name of ROOT data types
            case ToHash("Char_t"):
                typeinfo = &typeid(Char_t);
                size = sizeof(Char_t);
                break;
            case ToHash("UChar_t"):
                typeinfo = &typeid(UChar_t);
                size = sizeof(UChar_t);
                break;
            case ToHash("Short_t"):
                typeinfo = &typeid(Short_t);
                size = sizeof(Short_t);
                break;
            case ToHash("Int_t"):
                typeinfo = &typeid(Int_t);
                size = sizeof(Int_t);
                break;
            case ToHash("UInt_t"):
                typeinfo = &typeid(UInt_t);
                size = sizeof(UInt_t);
                break;
            case ToHash("Long_t"):
                typeinfo = &typeid(Long_t);
                size = sizeof(Long_t);
                break;
            case ToHash("ULong_t"):
                typeinfo = &typeid(ULong_t);
                size = sizeof(ULong_t);
                break;
            case ToHash("Long64_t"):
                typeinfo = &typeid(Long64_t);
                size = sizeof(Long64_t);
                break;
            case ToHash("ULong64_t"):
                typeinfo = &typeid(ULong64_t);
                size = sizeof(ULong64_t);
                break;
            case ToHash("Float_t"):
                typeinfo = &typeid(Float_t);
                size = sizeof(Float_t);
                break;
            case ToHash("Float16_t"):
                typeinfo = &typeid(Float16_t);
                size = sizeof(Float16_t);
                break;
            case ToHash("Double_t"):
                typeinfo = &typeid(Double_t);
                size = sizeof(Double_t);
                break;
            case ToHash("Double32_t"):
                typeinfo = &typeid(Double32_t);
                size = sizeof(Double32_t);
                break;
            case ToHash("LongDouble_t"):
                typeinfo = &typeid(LongDouble_t);
                size = sizeof(LongDouble_t);
                break;
            case ToHash("Bool_t"):
                typeinfo = &typeid(Bool_t);
                size = sizeof(Bool_t);
                break;
            default:
                break;
        }
        if (typeinfo != 0) {
            strcpy(this->name, name.c_str());
        }
    }
 
    template <typename T>
    DataType_Info(T* obj) {
        std::string name = "";
        if (typeid(T) == typeid(char)) {
            name = "char";
        } else if (typeid(T) == typeid(short)) {
            name = "short";
        } else if (typeid(T) == typeid(int)) {
            name = "int";
        } else if (typeid(T) == typeid(long)) {
            name = "long";
        } else if (typeid(T) == typeid(long int)) {
            name = "long int";
        } else if (typeid(T) == typeid(long long)) {
            name = "long long";
        } else if (typeid(T) == typeid(bool)) {
            name = "bool";
        } else if (typeid(T) == typeid(float)) {
            name = "float";
        } else if (typeid(T) == typeid(double)) {
            name = "double";
        } else if (typeid(T) == typeid(long double)) {
            name = "long double";
        } else if (typeid(T) == typeid(unsigned char)) {
            name = "unsigned char";
        } else if (typeid(T) == typeid(unsigned short)) {
            name = "unsigned short";
        } else if (typeid(T) == typeid(unsigned int)) {
            name = "unsigned int";
        } else if (typeid(T) == typeid(unsigned long)) {
            name = "unsigned long";
        } else if (typeid(T) == typeid(unsigned long long)) {
            name = "unsigned long long";
        } else if (typeid(T) == typeid(unsigned long int)) {
            name = "unsigned long int";
        } else if (typeid(T) == typeid(char*)) {
            name = "char*";
        }
 
        if (name != "") {
            strcpy(this->name, name.c_str());
            size = sizeof(T);
            typeinfo = &typeid(T);
        }
    }
};
 
EXTERN_DEF std::map<void*, TClass*> RESTListOfClasses_typeid;
EXTERN_DEF std::map<std::string, TClass*> RESTListOfClasses_typename;
 
inline TClass* GetClassQuick(std::string type) {
    auto iter = RESTListOfClasses_typename.find(type);
    if (iter != RESTListOfClasses_typename.end()) {
        return iter->second;
    } else {
        TClass* cl = TClass::GetClass(type.c_str());
        RESTListOfClasses_typename[type] = cl;
        return cl;
    }
    return nullptr;
}
 
template <typename T>
TClass* GetClassQuick() {
    void* typeidaddr = (void*)&typeid(T);
    auto iter = RESTListOfClasses_typeid.find(typeidaddr);
    if (iter != RESTListOfClasses_typeid.end()) {
        return iter->second;
    } else {
        TClass* cl = TClass::GetClass(typeid(T));
        RESTListOfClasses_typeid[typeidaddr] = cl;
        return cl;
    }
    return nullptr;
}
 
template <typename T>
std::string GetTypeName() {
    TClass* cl = TClass::GetClass(typeid(T));
    if (cl != nullptr) {
        return cl->GetName();
    }
    return std::string(DataType_Info((T*)0).name);
}
template <class T>
std::string GetTypeName(T obj) {
    return GetTypeName<T>();
}
 
class TRestReflector {
   private:
    int InitDictionary();
    bool onheap = false;
 
   public:
    std::string name = "";
    std::string type = "";
    const std::type_info* typeinfo = 0;
    char* address = 0;
    int size = 0;
    TClass* cl = 0;
    bool is_data_type = false;
    bool IsZombie();
    void operator>>(TRestReflector to);
    friend std::ostream& operator<<(std::ostream& cin, TRestReflector ptr) { return cin << ptr.ToString(); }
    template <typename T>
    T GetValue() {
        if (typeid(T) != *this->typeinfo) {
            std::cout << "In TRestReflector::GetValue() : type unmatch! " << std::endl;
            std::cout << "Input: " << GetTypeName<T>() << ", this: " << this->type << std::endl;
            return T();
        }
        if (address != nullptr) return *(T*)(address);
        return T();
    }
    template <class T>
    void SetValue(const T& val) {
        if (typeid(T) != *this->typeinfo) {
            std::cout << "In TRestReflector::SetValue() : type unmatch! " << std::endl;
            std::cout << "Input: " << GetTypeName<T>() << ", this: " << std::string(this->type) << std::endl;
            return;
        }
        if (address != nullptr) *((T*)(address)) = val;
    }
    std::string ToString();
    void ParseString(std::string str);
    void Assembly();
    void Destroy();
    void PrintMemory(int bytepreline = 16);
    TRestReflector GetDataMember(std::string name);
    TRestReflector GetDataMember(int ID);
    std::vector<std::string> GetListOfDataMembers();
    std::string GetDataMemberValueString(std::string name);
    int GetNumberOfDataMembers();
 
    template <class T>
    operator T*() {
        return (T*)address;
    }
    TRestReflector() {}
    TRestReflector(void* address, const std::string& type);
    template <class T>
    TRestReflector(const T& obj) {
        address = (char*)&obj;
        InitFromTemplate<T>();
    }
    template <class T>
    TRestReflector(T* obj) {
        address = (char*)obj;
        InitFromTemplate<T>();
    }
 
    template <class T>
    void InitFromTemplate() {
        onheap = false;
        cl = REST_Reflection::GetClassQuick<T>();
        DataType_Info dt = DataType_Info((T*)0);
        if (cl == nullptr && dt.size == 0) {
            std::cout << "In TRestReflector::TRestReflector() : unrecognized type! " << std::endl;
            return;
        }
 
        typeinfo = &typeid(T);
        is_data_type = dt.size > 0;
        size = sizeof(T);
        if (cl == nullptr) {
            type = dt.name;
        } else {
            type = cl->GetName();
        }
 
        InitDictionary();
    }
};
 
TRestReflector Assembly(std::string typeName);
 
TRestReflector WrapType(std::string typeName);
 
void CloneAny(TRestReflector from, TRestReflector to);
};  // namespace REST_Reflection
 
typedef REST_Reflection::TRestReflector RESTValue;
 
class RESTVirtualConverter {
   public:
    virtual std::string ToString(void* obj) = 0;
    virtual void ParseString(void* obj, std::string str) = 0;
    virtual void CloneObj(void* from, void* to) = 0;
};
 
// type name, {toString method, parseString method}
EXTERN_DEF std::map<size_t, RESTVirtualConverter*> RESTConverterMethodBase;
 
template <class T>
class Converter : RESTVirtualConverter {
   public:
    std::string (*ToStringFunc)(T);
    T (*ParseStringFunc)(std::string);
    static Converter<T>* thisptr;
 
    std::string ToString(void* obj) override { return ToStringFunc(*(T*)obj); }
    void ParseString(void* obj, std::string str) override {
        T newobj = ParseStringFunc(str);
        *((T*)(obj)) = newobj;
    }
    void CloneObj(void* from, void* to) override { *((T*)(to)) = *((T*)(from)); }
 
    Converter(std::string (*_ToStringFunc)(T), T (*_ParseStringFunc)(std::string)) {
        ToStringFunc = _ToStringFunc;
        ParseStringFunc = _ParseStringFunc;
        if (RESTConverterMethodBase.count(typeid(T).hash_code()) > 0) {
            std::cout << "Warning! converter for type: " << typeid(T).name() << " already added!"
                      << std::endl;
        } else {
            RESTConverterMethodBase[typeid(T).hash_code()] = this;
        }
 
        // std::string type_name_actual = REST_Reflection::GetTypeName<T>();  // in case ROOT redefines type
        // name if (RESTConverterMethodBase.count(type_name_actual) == 0) {
        //    RESTConverterMethodBase[type_name_actual] = this;
        //}
    }
};
 
#define AddConverter(ToStringFunc, ParseStringFunc, type) \
    template <>                                           \
    Converter<type>* Converter<type>::thisptr = new Converter<type>(&ToStringFunc, &ParseStringFunc);
 
#endif