uscript::TClassList Class Reference

#include <tclass.h>

Public Member Functions
TClassInfo *	Add (const char *classname)

Public Attributes
std::unordered_map< const char *, TClassInfo >	classes

Detailed Description

Definition at line 44 of file tclass.h.

Member Function Documentation

uscript::TClassInfo * uscript::TClassList::Add

(

const char *

classname

)

Definition at line 16 of file tclass.cc.

                                                               {
  classname = uscript::Compiler::Intern(std::string(classname));
  auto search = classes.find(classname);
  // already added -- ok
  if (search != classes.end()) {
    return &search->second;
  }

  DictFuncPtr_t classdict = gClassTable->GetDict(classname);

  // no classdict -- bad
  if (!classdict) return NULL;

  std::map<const char *, uscript::TField> fields;

  TClass *tclass = classdict();

  // handle vector case
  if (tclass->GetCollectionType() == ROOT::kSTLvector) {
    TClassInfo tclassinfo;
    tclassinfo.is_vec = true;
    tclassinfo.name = classname; 
    tclassinfo.size = sizeof(std::vector<void*>); // all vectors in layout should have the same size

    TClassEdit::TSplitType split(classname);
    // get the dictionary for the sub-class
    classdict = gClassTable->GetDict(split.fElements[1].c_str());

    // vec data
    uscript::TData data;
    data.len = -1;
    data.info = NULL;

    if (classdict == NULL) {
      // try to see if it is a basic type
      if (split.fElements[1] == "bool" || split.fElements[1] == "Bool_t") {
        data.type = uscript::FIELD_BOOL; 
      }
      else if (split.fElements[1] == "float" || split.fElements[1] == "Float_t") {
        data.type = uscript::FIELD_FLOAT;
      }
      else if (split.fElements[1] == "double" || split.fElements[1] == "Double_t") {
        data.type = uscript::FIELD_DOUBLE;
      }
      else if (split.fElements[1] == "int" || split.fElements[1] == "Int_t") {
        data.type = uscript::FIELD_INT;
      }
      else if (split.fElements[1] == "unsigned" || split.fElements[1] == "UInt_t") {
        data.type = uscript::FIELD_UNSIGNED;
      }
      else return NULL;
    }
    // a dictionary exists -- try to add it
    else {
      TClassInfo *sub_info = Add(split.fElements[1].c_str());
      data.info = sub_info;
      data.type = uscript::FIELD_TINSTANCE;
    }

    tclassinfo.vec_data = data;
    return &classes.insert({classname, tclassinfo}).first->second;
  }

  TList *members = tclass->GetListOfDataMembers();
  TIterator *m_iterator = members->MakeIterator();
  TObject *obj;
  while ((obj = m_iterator->Next()) != NULL) {
    TDataMember *member = (TDataMember *)obj;

    uscript::TField this_field;
    this_field.offset = member->GetOffset();
    bool can_use = true;
    TDataType *basic_type = member->GetDataType();

    // get size
    this_field.data.len = -1;
    if (member->GetArrayDim() > 0) {
      this_field.data.len = 1;
      for (unsigned i = 0; i < member->GetArrayDim(); i++) {
        this_field.data.len = this_field.data.len * member->GetMaxIndex(i);
      }
    }

    // treat enum as unsigned with size 4
    if (member->IsEnum()) {
      this_field.data.info = NULL; // no tclass info
      this_field.data.type = uscript::FIELD_ENUM;
      assert(member->GetUnitSize() == 4);// make sure size is actually 4
    }
    // non-enum basic type
    else if (basic_type != NULL) {
      this_field.data.info = NULL; // no tclass info
      switch (basic_type->GetType()) {
        case kBool_t:
          this_field.data.type = uscript::FIELD_BOOL;
          break;
        case kFloat_t:
          this_field.data.type = uscript::FIELD_FLOAT;
          break;
        case kDouble_t:
          this_field.data.type = uscript::FIELD_DOUBLE;
          break;
        case kInt_t:
          this_field.data.type = uscript::FIELD_INT;
          break;
        case kUInt_t:
          this_field.data.type = uscript::FIELD_UNSIGNED;
          break;
        default: // don't allow any other field type
          can_use = false;
          break;
      }
    }
    // complex-type (TClass)
    else {
      // must have a class dictionary
      uscript::TClassInfo *field_info = Add(member->GetTypeName());
      if (field_info != NULL) {
        this_field.data.type = uscript::FIELD_TINSTANCE;
        this_field.data.info = field_info;
      }
      else {
        can_use = false;
      }
    }
    if (can_use) {
      fields[uscript::Compiler::Intern(std::string(obj->GetName()))] = this_field;
    }
  }
  uscript::TClassInfo tclassinfo;
  tclassinfo.fields = std::move(fields);
  tclassinfo.name = classname;
  tclassinfo.size = tclass->GetClassSize();
  tclassinfo.is_vec = false;
  return &classes.insert({classname, tclassinfo}).first->second;
}

Member Data Documentation

std::unordered_map<const char *, TClassInfo> uscript::TClassList::classes

Definition at line 47 of file tclass.h.

---

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

• tclass.h
• tclass.cc