QObjectInspector.cc

Go to the documentation of this file.

#include "QObjectInspector.hh"
#include "QObject.hh"
#include "TDataMember.h"
#include "TClass.h"
#include <sstream>
 
 
Q_BEGIN_NAMESPACE 
 
QObjectInspector::QObjectInspector()
{
}
 
QObjectInspector::MemberInfo QObjectInspector::FindBaseType(QObject* obj, const char* member)
{
    MemberInfo info;
    info.fAddress = 0;
    info.fType = "Unknown";
    info.fBranchType = "Unknown";
    info.fStringValue = "Unknown";
#if ROOT_VERSION_CODE < ROOT_VERSION(5,28,0)
    char parent[512];
    parent[0] = 0;
    obj->ShowMembers(*this,parent);
#else
    obj->ShowMembers(*this);
#endif
    std::map<std::string, MemberInfo>::const_iterator iter = fBaseTypeMembers.find(member);
    if(iter != fBaseTypeMembers.end()) info = iter->second;
    return info;
 
}
 
QError QObjectInspector::DumpOnStream(const QObject* obj, std::ostream& str)
{
    // work around const...
    void** vobj = (void**)&obj;
    QObject* vvobj = (QObject*) *vobj;
 
#if ROOT_VERSION_CODE < ROOT_VERSION(5,28,0)
    char parent[512];
    parent[0] = 0;
    vvobj->ShowMembers(*this,parent);
#else
    vvobj->ShowMembers(*this);
#endif
 
    QError err = QERR_SUCCESS;
    std::map<std::string, MemberInfo>::const_iterator iter;
 
    if(!fOtherMembers.empty()) {
        err = QERR_UNKNOWN_ERR;
        std::stringstream msg;
        if(fOtherMembers.size() > 1) msg<<"Members ";
        else msg<<"Member ";
        iter = fOtherMembers.begin();
        while(iter != fOtherMembers.end()) {
            msg<<iter->first<<"("<<iter->second.fType<<")"<<" ";
            iter++;
        }
        msg<<" cannot be handled by QObjectInspector. Implement the WriteOnStream method of this QObject!";
        err.SetDescription(__FILE__,__LINE__,msg.str());
    }
 
 
 
    iter = fBaseTypeMembers.begin();
    while(iter != fBaseTypeMembers.end()) {
        str<<iter->first<<" "<<iter->second.fStringValue<<std::endl;
        iter++;
    }
 
    return err;
 
}
 
QError QObjectInspector::FillFromStream(QObject* obj, std::istream& in)
{
 
    obj->Clear();
    QError err = QERR_SUCCESS;
#if ROOT_VERSION_CODE < ROOT_VERSION(5,28,0)
    char parent[512];
    parent[0] = 0;
    obj->ShowMembers(*this,parent);
#else
    obj->ShowMembers(*this);
#endif
 
 
    if(!fOtherMembers.empty()) {
        err = QERR_UNKNOWN_ERR;
        std::stringstream msg;
        if(fOtherMembers.size() > 1) msg<<"Members ";
        else msg<<"Member ";
        std::map<std::string, MemberInfo>::const_iterator iter = fOtherMembers.begin();
        while(iter != fOtherMembers.end()) {
            msg<<iter->first<<" ";
            iter++;
        }
        msg<<" cannot be handled by QObjectInspector. Implement the ReadFromStream method of this QObject!";
        err.SetDescription(__FILE__,__LINE__,msg.str());
    }
 
 
    std::map<std::string,std::string> parValueMap;
    std::string line;
    while(getline(in, line)) {
        if(in.fail()) break;
        std::stringstream stream(line);
        std::string label,value;
        stream>>label>>value;
        while(stream.good()) {
            std::string newval;
            stream>>newval;
            value += " " + newval;
        }
        parValueMap[label]=value;
    }
 
    std::map<std::string, MemberInfo>::iterator iter = fBaseTypeMembers.begin();
    while(iter != fBaseTypeMembers.end()) {
        if(parValueMap.find(iter->first) != parValueMap.end()) {
            if(iter->second.fIsPointer) {
                int size = atoi(parValueMap.find(iter->second.fLengthMember)->second.c_str());
                Resize(iter->second,size);
 
                std::stringstream str;
                str<<parValueMap[iter->first];
                std::string value;
                for(int i = 0; i < size; i++) {
                    str>>value;
                    char** apos = (char**) (iter->second.fAddress);
                    char* pos = *apos;
                    pos += (i*iter->second.fMemberSize);
                    Assign(pos,iter->second.fEDataType,value);
 
                }
            } else if(iter->second.fType == "string") {
                (*(std::string*)iter->second.fAddress) = parValueMap[iter->first];
            } else {
                Assign(iter->second.fAddress,iter->second.fEDataType,parValueMap[iter->first]);
 
            }
 
        } else {
            err = QERR_UNKNOWN_ERR;
            std::stringstream msg;
            msg<<"Member \""<<iter->first<<"\" not found";
            err.SetDescription(msg.str());
        }
        iter++;
    }
 
    return err;
}
 
 
void QObjectInspector::Inspect(TClass* cl, const char* parent, const char* mname, const void* addr) 
{
    TDataMember *member = cl->GetDataMember(mname) ;
//   std::cout<<"BBBB: "<<lastParent<<" "<<parent<<std::endl;
    if (member != 0) {
        std::string memberTypeName = member->GetTypeName();
        std::string memberName = member->GetName();
        std::string fullName = std::string(parent) + memberName;
        bool isapointer = member->IsaPointer();
        bool isbasic = member->IsBasic();
        bool ispersistent = member->IsPersistent();
        bool isQObject = 0;
        TDataType* membertype = member->GetDataType();
        MemberInfo info;
        TClass* classa = TClass::GetClass(memberTypeName.c_str(),kTRUE, kTRUE);
        if(classa && classa->InheritsFrom("TObject")) isQObject = 1;
     //   std::cout<<"AAA Parent: "<<parent<<" Member: "<<fullName<<" QObject: "<<isQObject<<" Type: "<<memberTypeName<<std::endl;
        info.fType = memberTypeName;
        info.fAddress = (void*)addr;
        info.fIsPointer = isapointer;
        info.fSize = -1;
        info.fIsQObject = isQObject;
        if(isQObject ) {
         // do nothing
        } else if(isbasic && ispersistent && memberName != "fBits" && memberName != "fUniqueID") {
            info.fBranchType = TypeToBranchType((EDataType) membertype->GetType());
            info.fEDataType = (EDataType) membertype->GetType();
            info.fMemberSize = membertype->Size();;
            if(isapointer) {
                info.fLengthMember = std::string(parent) + member->GetArrayIndex();
 
                QVdt vsize = fBaseTypeMembers[info.fLengthMember].fStringValue;
                int size = vsize.GetInt();
                info.fStringValue = "";
                for(int i =0; i < size; i++) {
                    info.fStringValue += " ";
                    char** apos = (char**) (info.fAddress);
                    char* pos = *apos;
                    pos += (i*membertype->Size());
                    info.fStringValue += membertype->AsString((void*)pos);
                }
 
                info.fSize = size;
 
            } else {
                info.fStringValue = membertype->AsString(info.fAddress);
            }
            fBaseTypeMembers[fullName] = info;
        } else if(ispersistent && memberName != "fBits" && memberName != "fUniqueID")  {
            if(info.fType == "string") {
                info.fStringValue = *(std::string*)(info.fAddress);    
                fBaseTypeMembers[fullName] = info;
            }  else {
                //    std::cout<<"AAAAAAAA: "<<membertype->GetName()<<" "<<info.fAddress<<" val: "<<info.fStringValue<<std::endl;
                fOtherMembers[fullName] = info;
            }
 
        }     
    }
}
 
 
std::string QObjectInspector::TypeToBranchType(EDataType mtypes)
{
    std::string stringType = "Unknown";
    switch(mtypes) {
        case kChar_t: 
            stringType = "B"; // an 8 bit signed integer    
            break;
        case kUChar_t: 
            stringType = "b"; // an 8 bit unsigned integer 
            break;
        case kShort_t: 
            stringType = "S"; // a 16 bit signed integer   
            break;
        case kUShort_t: 
            stringType = "s"; // a 16 bit unsigned integer 
            break;
        case kInt_t: 
            stringType = "I"; // a 32 bit signed integer   
            break;
        case kUInt_t: 
            stringType = "i"; // a 32 bit unsigned integer 
            break;
        case kFloat_t: 
            stringType = "F"; // a 32 bit floating point   
            break;
        case kDouble_t: 
            stringType = "D"; // a 64 bit floating point   
            break;
        case kLong64_t: 
            stringType = "L"; // a 64 bit signed integer   
            break;
        case kULong64_t: 
            stringType = "l"; // a 64 bit unsigned integer 
            break;
        case kBool_t: 
            stringType = "O"; // a boolean                 
            break;
        default:
            stringType = "Unknown";
            break;
    }
    return stringType;
}
 
void QObjectInspector::Assign(void* addr,EDataType dataType,const std::string& value)
{
    switch(dataType) {
        case kChar_t: 
            if(!value.empty())
                (*(char*)addr) = value[0];
            else 
                (*(char*)addr) = '\0';
            break;
        case kUChar_t: 
            if(!value.empty())
                (*(unsigned char*)addr) = value[0];
            else 
                (*(unsigned char*)addr) = '\0';
            break;
        case kShort_t: 
            if(!value.empty())
                (*(short*)addr) = atoi(value.c_str());
            else 
                (*(short*)addr) = Q_SHORT_DEFAULT;
            break;
        case kUShort_t: 
            if(!value.empty())
                (*(unsigned short*)addr) = atoi(value.c_str());
            else 
                (*(unsigned short*)addr) = Q_SHORT_DEFAULT;
            break;
        case kInt_t: 
            if(!value.empty())
                (*(int*)addr) = atoi(value.c_str());
            else 
                (*(int*)addr) = Q_INT_DEFAULT;
            break;
        case kUInt_t: 
            if(!value.empty())
                (*(unsigned int*)addr) = atoi(value.c_str());
            else 
                (*(unsigned int*)addr) = Q_INT_DEFAULT;
            break;
        case kFloat_t: 
            if(!value.empty())
                (*(float*)addr) = atof(value.c_str());
            else 
                (*(float*)addr) = Q_DOUBLE_DEFAULT;
            break;
        case kDouble_t: 
            if(!value.empty())
                (*(double*)addr) = atof(value.c_str());
            else 
                (*(double*)addr) = Q_DOUBLE_DEFAULT;
            break;
        case kLong64_t: 
            if(!value.empty())
                (*(Long64_t*)addr) = atoi(value.c_str());
            else 
                (*(Long64_t*)addr) = Q_INT_DEFAULT;
            break;
        case kULong64_t: 
            if(!value.empty())
                (*(Long64_t*)addr) = atoi(value.c_str());
            else 
                (*(Long64_t*)addr) = Q_INT_DEFAULT;
            break;
        case kBool_t: 
            if(!value.empty())
                (*(bool*)addr) = atoi(value.c_str());
            else 
                (*(bool*)addr) = Q_INT_DEFAULT;
            break;
        default:
            break;
    }
 
}
 
void QObjectInspector::Resize(MemberInfo& info, int size)
{
    switch(info.fEDataType) {
        case kChar_t: 
            {
                char** oaddr = (char**)info.fAddress;
                char* addr = (char*)*oaddr;
                if(addr) delete [] addr;   
                *oaddr = new char[size];
                break;
            }
        case kUChar_t: 
            {
                unsigned char** oaddr = (unsigned char**)info.fAddress;
                unsigned char* addr = (unsigned char*)*oaddr;
                if(addr) delete [] addr;   
                *oaddr = new unsigned char[size];
                break;
            }
        case kShort_t: 
            {
                short** oaddr = (short**)info.fAddress;
                short* addr = (short*)*oaddr;
                if(addr) delete [] addr;   
                *oaddr = new short[size];
                break;
            }
        case kUShort_t: 
            {
                unsigned short** oaddr = (unsigned short**)info.fAddress;
                unsigned short* addr = (unsigned short*)*oaddr;
                if(addr) delete [] addr;   
                *oaddr = new unsigned short[size];
                break;
            }
        case kInt_t: 
            {
                int** oaddr = (int**)info.fAddress;
                int* addr = (int*)*oaddr;
                if(addr) delete [] addr;   
                *oaddr = new int[size];
                break;
            }
        case kUInt_t: 
            {
                unsigned int** oaddr = (unsigned int**)info.fAddress;
                unsigned int* addr = (unsigned int*)*oaddr;
                if(addr) delete [] addr;   
                *oaddr = new unsigned int[size];
                break;
            }
        case kFloat_t: 
            {
                float** oaddr = (float**)info.fAddress;
                float* addr = (float*)*oaddr;
                if(addr) delete [] addr;   
                *oaddr = new float[size];
                break;
            }
        case kDouble_t: 
            {
                double** oaddr = (double**)info.fAddress;
                double* addr = *oaddr;
                if(addr) delete [] addr;   
                *oaddr = new double[size];
                break;
            }
        case kLong64_t: 
            {
                Long64_t** oaddr = (Long64_t**)info.fAddress;
                Long64_t* addr = *oaddr;
                if(addr) delete [] addr;   
                *oaddr = new Long64_t[size];
                break;
            }
        case kULong64_t: 
            {
                ULong64_t** oaddr = (ULong64_t**)info.fAddress;
                ULong64_t* addr = (ULong64_t*)*oaddr;
                if(addr) delete [] addr;   
                *oaddr = new ULong64_t[size];
                break;
            }
        case kBool_t: 
            {
 
                bool** oaddr = (bool**)info.fAddress;
                bool* addr = (bool*)*oaddr;
                if(addr) delete [] addr;   
                *oaddr = new bool[size];
                break;
            }
        default:
            break;
    }
 
}
 
Q_END_NAMESPACE