template <class T> bool print_root_classname(const T *obj, const char* expect) {
TClass *cl = testGetClass(typeid(*obj));
if (!cl || strcmp(cl->GetName(),expect)!=0 ) {
cerr << "ERROR: in retrieving TClass";
if (cl) { cerr << " found " << cl->GetName() << endl; }
else { cerr << " NOT found!" << endl; };
return 0;
}
cerr << cl->GetName() << endl;
return 1;
}
void TestSchemaEvolution::loopOnBases(TClass *tcl) {
TList *bases = tcl->GetListOfBases();
TIter next(bases);
while (TObject *obj = next()) {
TClass *cl = TClass::GetClass(obj->GetName());
if (cl && cl->HasDictionary()) {
unique_classes_.insert(std::make_pair(cl->GetName(), cl->GetClassVersion()));
analyseClass(cl);
}
}
}
void TestSchemaEvolution::loopOnDataMembers(TClass *tcl) {
TList *dms = tcl->GetListOfDataMembers();
TIter next(dms);
while (TObject *obj = next()) {
TClass *cl = TClass::GetClass(((TDataMember *)obj)->GetFullTypeName());
if (cl && cl->HasDictionary()) {
unique_classes_.insert(std::make_pair(cl->GetName(), cl->GetClassVersion()));
analyseClass(cl);
}
}
}
void vector_int_cint()
{
gROOT->ProcessLine(".autodict"); // disable auto building of dictionaries.
const std::type_info& t = edm::Wrapper<vector<int> >::typeInfo();
TClass* tc = TClass::GetClass(t);
std::cout << tc->GetName() << std::endl;
TFile f1("vectorinttest.root");
fwlite::Event ev(&f1);
fwlite::Handle<vector<int> > vip;
for (ev.toBegin(); ! ev.atEnd(); ++ev) {
edm::EventID id = ev.id();
cout << "Run " << id.run() << " event " << id.event() << endl;
vip.getByLabel(ev,"VIP");
for (unsigned int i=0; i != vip.ref().size(); ++i) {
cout <<vip.ref().at(i)<<" ";
}
cout << endl;
}
}
void ojtable(const char *className)
{
static int fTableOffset = 0;
if (!fTableOffset) fTableOffset = gObjectTable->IsA()->GetDataMemberOffset("fTable");
// gObjectTable->Print();
TClass *kl;
if (className && !*className) className=0;
const char *qwe = ".*";
if (className) qwe = className;
TRegexp regexp(qwe);
int regexpLen=0;
int sz = gObjectTable->GetSize();
int *ptr = new int[sz];
int *idx = new int[sz];
TObject **tab = *((TObject ***)((char*)gObjectTable+fTableOffset));
TObject *to;
printf ("tab %p[%d]\n",tab,sz);
int i,num=0;
double hSize=0;
int hNumb=0;
const char *info_name = 0;
for (i=0; i<sz; i++)
{
to = tab[i];
if (!to) continue;
if (!to->TestBit(TObject::kNotDeleted)) continue;
int hs = SizeOfH(to);
if (hs) {
hSize+=hs;
hNumb++;
}
if (className && regexp.Index(to->ClassName(),®expLen)<0) continue;
const char *mk = StMkDeb::GetUser(to);
if(mk && *mk) printf("%s(%p) in %s\n",to->ClassName(),to,mk);
ptr[num++]=int(to);
}
printf("TH1 N=%d, Size = %g\n",hNumb,hSize);
TMath::Sort(num,ptr,idx,0);
int last = 0;
printf("Selected %d objects\n",num);
for (i=0; i<num; i++) {
int ix = idx[i];
to = (TObject*)ptr[ix];
int dist = 0;
if (i) dist = ptr[ix]-last;
last = ptr[ix];
// if ((int)to == 0xc94ff34) {
// printf("Skipped %p\n",to); continue; }
info_name = "??";
info_name=typeid(*to).name();
kl = to->IsA();
printf ("%4d +%6d : obj = %p(%3d) %s::%s \tinfo=%s\n",i,dist,to,kl->Size(),kl->GetName(),to->GetName(),info_name);
if (strcmp("TClonesArray",kl->GetName())) continue;
TClonesArray *tcl = ((TClonesArray*)to);
printf(" Sizes = %d %d\n",tcl->GetLast()+1,tcl->Capacity());
tcl->ls("");
}
delete [] ptr;
delete [] idx;
}
int runGetMissingDictionaries()
{
// Method to assert the dictionaries.
TClass* myClass = TClass::GetClass("TestClass");
if (myClass->HasDictionary())
Error("TClass::HasDictionary", "The class %s does not have a dictionary.", "TestClass");
THashTable expectedResult;
// Hard coded expected results.
expectedResult.Add(TClass::GetClass("NoDictClass"));
expectedResult.Add(TClass::GetClass("TestClass"));
expectedResult.Add(TClass::GetClass("MemberHidden"));
expectedResult.Add(TClass::GetClass("Tmplt<Tmplt<NoDictClass*> >"));
expectedResult.Add(TClass::GetClass("Tmplt<int>"));
expectedResult.Add(TClass::GetClass("Member"));
expectedResult.Add(TClass::GetClass("Tmplt<Member>"));
expectedResult.Add(TClass::GetClass("Tmplt<Base>"));
expectedResult.Add(TClass::GetClass("Outer<Double32_t>"));
expectedResult.Add(TClass::GetClass("Tmplt<TmpParam>"));
expectedResult.Add(TClass::GetClass("Tmplt<Tmplt<TmpTmpParam> >"));
expectedResult.Add(TClass::GetClass("Tmplt<Tmplt<Tmplt<ExtraTmp> > >"));
expectedResult.Add(TClass::GetClass("ParamList<ParamL1,ParamL2>"));
expectedResult.Add(TClass::GetClass("TypedefExample"));
expectedResult.Add(TClass::GetClass("BasicTests::TestAll"));
cerr<<"No recursion:"<<endl; // Write on the same stream of the errors below
THashTable missingDictClassesNoRecursion;
// Assert GetMissingDictionaries without recursion.
myClass->GetMissingDictionaries(missingDictClassesNoRecursion, false);
//missingDictClassesNoRecursion.Print();
if (!missingDictClassesNoRecursion.IsEmpty()) {
if (missingDictClassesNoRecursion.GetEntries() != expectedResult.GetEntries()) {
Error("TClass::GetMissingClassDictionaries", "The set of classes with missing dictionaries does not contain the correct number of elements (expected: %d got %d).",expectedResult.GetEntries(),missingDictClassesNoRecursion.GetEntries());
}
TIterator* it = missingDictClassesNoRecursion.MakeIterator();
TClass* cl = 0;
while ((cl = (TClass*)it->Next())) {
if (!expectedResult.FindObject(cl)) {
Error("TCling::GetMissingDictionaries", "Class %s is not in the expected set.", cl->GetName());
}
}
it = expectedResult.MakeIterator();
while ((cl = (TClass*)it->Next())) {
if (!missingDictClassesNoRecursion.FindObject(cl)) {
Error("TCling::GetMissingDictionaries", "Class %s with no dictionaries is not in the set.", cl->GetName());
}
}
} else {
Error("TClass::GetMissingClassDictionaries", "The set of missing classes is not created");
}
// Assert GetMissingDictionaries with recursion.
// Hard code expected results with recursion.
expectedResult.Add(TClass::GetClass("ArrayTry"));
expectedResult.Add(TClass::GetClass("NoA"));
expectedResult.Add(TClass::GetClass("vector<Tmplt<NoDictClass*> >"));
expectedResult.Add(TClass::GetClass("Tmplt<NoDictClass*>"));
expectedResult.Add(TClass::GetClass("vector<Member>"));
expectedResult.Add(TClass::GetClass("Base"));
expectedResult.Add(TClass::GetClass("vector<Base>"));
expectedResult.Add(TClass::GetClass("Inner<Double32_t>"));
expectedResult.Add(TClass::GetClass("TmpParam"));
expectedResult.Add(TClass::GetClass("TmpTmpParam"));
expectedResult.Add(TClass::GetClass("Tmplt<TmpTmpParam>"));
expectedResult.Add(TClass::GetClass("ExtraTmp"));
expectedResult.Add(TClass::GetClass("Tmplt<ExtraTmp>"));
expectedResult.Add(TClass::GetClass("Tmplt<Tmplt<ExtraTmp> >"));
expectedResult.Add(TClass::GetClass("vector<Tmplt<Tmplt<ExtraTmp> > >"));
expectedResult.Add(TClass::GetClass("vector<NoDictClass*> "));
expectedResult.Add(TClass::GetClass("vector<TmpTmpParam>"));
expectedResult.Add(TClass::GetClass("vector<Tmplt<ExtraTmp> >"));
expectedResult.Add(TClass::GetClass("vector<ExtraTmp> "));
expectedResult.Add(TClass::GetClass("vector<Tmplt<TmpTmpParam> >"));
expectedResult.Add(TClass::GetClass("vector<TmpParam>"));
expectedResult.Add(TClass::GetClass("vector<Double32_t>"));
expectedResult.Add(TClass::GetClass("ParamL1"));
expectedResult.Add(TClass::GetClass("ParamL2"));
expectedResult.Add(TClass::GetClass("vector<ParamL2*>"));
expectedResult.Add(TClass::GetClass("BasicTests::NoDictTypdefs"));
expectedResult.Add(TClass::GetClass("BasicTests::NoDict"));
expectedResult.Add(TClass::GetClass("BasicTests::HasVecDoubleTD32"));
expectedResult.Add(TClass::GetClass("BasicTests::HasVecDouble32"));
expectedResult.Add(TClass::GetClass("map<unsigned short,Double32_t>"));
cerr<<"With recursion:"<<endl; // Write on the same stream of the errors below
THashTable missingDictClassesRecursion;
myClass->GetMissingDictionaries(missingDictClassesRecursion, true);
//missingDictClassesRecursion.Print();
if (!missingDictClassesRecursion.IsEmpty()) {
if (missingDictClassesRecursion.GetEntries() != expectedResult.GetEntries()) {
Error("TClass::GetMissingClassDictionaries", "The set of classes with missing dictionaries does not contain the correct number of elements (expected: %d got %d).",expectedResult.GetEntries(),missingDictClassesRecursion.GetEntries());
// expectedResult.ls();
// missingDictClassesRecursion.ls();
}
TIterator* it = missingDictClassesRecursion.MakeIterator();
TClass* cl = 0;
while ((cl = (TClass*)it->Next())) {
if (!expectedResult.FindObject(cl)) {
Error("TCling::GetMissingDictionaries", "Class %s is not in the expected set.", cl->GetName());
}
}
it = expectedResult.MakeIterator();
while ((cl = (TClass*)it->Next())) {
if (!missingDictClassesRecursion.FindObject(cl)) {
Error("TCling::GetMissingDictionaries", "Class %s with no dictionaries is not in the set.", cl->GetName());
}
}
} else {
Error("TClass::GetMissingClassDictionaries", "The set of missing classes is not created");
}
return 0;
}
void classesFromBranch(TBranch *tbranch, TClass *tclass, std::vector<ClassStructure> &classes, int prefix, std::set<std::string> &includes) {
std::string className = tclass->GetName();
if (className == std::string("TObject"))
includes.insert("#include \"TObject.h\"");
else if (className == std::string("TRef"))
includes.insert("#include \"TRef.h\"");
else if (className == std::string("TRefArray"))
includes.insert("#include \"TRefArray.h\"");
else if (className == std::string("TH1"))
includes.insert("#include \"TH1.h\"");
else if (className == std::string("TBits")) {
includes.insert("#include \"TBits.h\"");
}
else {
bool classSeen = false;
for (int i = 0; i < classes.size(); i++)
if (classes[i].fullName == className)
classSeen = true;
if (!classSeen) {
TVirtualStreamerInfo *tVirtualStreamerInfo = tclass->GetStreamerInfo();
int version = tVirtualStreamerInfo->GetClassVersion();
ClassStructure classStructure(tclass, version);
if (tVirtualStreamerInfo->GetElements()->GetEntries() == 1 &&
((TStreamerElement*)(tVirtualStreamerInfo->GetElements()->First()))->IsBase() &&
std::string(tVirtualStreamerInfo->GetElements()->First()->GetName()) == std::string("TObjArray")) {
TVirtualStreamerInfo *substreamer = ((TBranchElement*)tbranch)->GetInfo();
if (std::string(substreamer->GetName()) == std::string("TClonesArray")) {
ROOT::Internal::TTreeGeneratorBase ttreeGenerator(tbranch->GetTree(), "");
TString className = ttreeGenerator.GetContainedClassName((TBranchElement*)tbranch, (TStreamerElement*)(substreamer->GetElements()->First()), true);
classesFromBranch(tbranch, TClass::GetClass(className), classes, prefix + std::string(tbranch->GetName()).size() + 1, includes);
}
}
TIter elements = tVirtualStreamerInfo->GetElements();
for (TStreamerElement *tStreamerElement = (TStreamerElement*)elements.Next(); tStreamerElement != nullptr; tStreamerElement = (TStreamerElement*)elements.Next()) {
std::string streamerName = tStreamerElement->GetName();
if (tStreamerElement->IsBase()) {
TClass *elementClass = tStreamerElement->GetClassPointer();
std::string type = elementClass->GetName();
if (type == std::string("TObject")) {
classStructure.bases.push_back(type);
includes.insert(std::string("#include \"") + type + std::string(".h\""));
}
}
else {
TIter listOfBranches = tbranch->GetListOfBranches();
TBranch *subbranch;
for (subbranch = (TBranch*)listOfBranches.Next(); subbranch != nullptr; subbranch = (TBranch*)listOfBranches.Next()) {
std::string branchName = subbranch->GetName();
branchName = branchName.substr(prefix, std::string::npos);
int firstDot = branchName.find('.');
int firstBracket = branchName.find('[');
if (firstDot != std::string::npos && firstBracket != std::string::npos)
branchName = branchName.substr(0, firstDot < firstBracket ? firstDot : firstBracket);
else if (firstDot != std::string::npos)
branchName = branchName.substr(0, firstDot);
else if (firstBracket != std::string::npos)
branchName = branchName.substr(0, firstBracket);
if (branchName == streamerName)
break;
}
if (subbranch == nullptr)
continue;
std::string branchName = subbranch->GetName();
std::string variable = tStreamerElement->GetName();
std::string variableWithArray = subbranch->GetName();
variableWithArray = variableWithArray.substr(prefix, std::string::npos);
variableWithArray = variableWithArray.substr(0, variableWithArray.find('.'));
std::string comment = tStreamerElement->GetTitle();
std::string type;
Bool_t pointer = false;
switch (tStreamerElement->GetType()) {
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kBool:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kBool:
case TVirtualStreamerInfo::kBool:
type = "Bool_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kChar:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kChar:
case TVirtualStreamerInfo::kChar:
type = "Char_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kShort:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kShort:
case TVirtualStreamerInfo::kShort:
type = "Short_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kInt:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kInt:
case TVirtualStreamerInfo::kInt:
type = "Int_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kLong:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kLong:
case TVirtualStreamerInfo::kLong:
type = "Long_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kLong64:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kLong64:
case TVirtualStreamerInfo::kLong64:
type = "Long64_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kFloat:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kFloat:
case TVirtualStreamerInfo::kFloat:
type = "Float_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kFloat16:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kFloat16:
case TVirtualStreamerInfo::kFloat16:
type = "Float16_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kDouble:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kDouble:
case TVirtualStreamerInfo::kDouble:
type = "Double_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kDouble32:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kDouble32:
case TVirtualStreamerInfo::kDouble32:
type = "Double32_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kUChar:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kUChar:
case TVirtualStreamerInfo::kUChar:
type = "UChar_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kUShort:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kUShort:
case TVirtualStreamerInfo::kUShort:
type = "UShort_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kUInt:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kUInt:
case TVirtualStreamerInfo::kUInt:
type = "UInt_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kULong:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kULong:
case TVirtualStreamerInfo::kULong:
type = "ULong_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kULong64:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kULong64:
case TVirtualStreamerInfo::kULong64:
type = "ULong64_t";
break;
case TVirtualStreamerInfo::kOffsetP + TVirtualStreamerInfo::kBits:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kBits:
case TVirtualStreamerInfo::kBits:
type = "UInt_t";
break;
case TVirtualStreamerInfo::kCharStar:
type = "Char_t*";
break;
case TVirtualStreamerInfo::kCounter:
type = "Int_t";
break;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kObjectp:
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kObjectP:
case TVirtualStreamerInfo::kObjectp:
case TVirtualStreamerInfo::kObjectP:
case TVirtualStreamerInfo::kAnyp:
case TVirtualStreamerInfo::kAnyP:
case TVirtualStreamerInfo::kSTL + TVirtualStreamerInfo::kObjectp:
case TVirtualStreamerInfo::kSTL + TVirtualStreamerInfo::kObjectP:
pointer = true;
case TVirtualStreamerInfo::kOffsetL + TVirtualStreamerInfo::kObject:
case TVirtualStreamerInfo::kObject:
case TVirtualStreamerInfo::kTString:
case TVirtualStreamerInfo::kTNamed:
case TVirtualStreamerInfo::kTObject:
case TVirtualStreamerInfo::kAny:
case TVirtualStreamerInfo::kBase:
case TVirtualStreamerInfo::kSTL:
TClass *elementClass = tStreamerElement->GetClassPointer();
type = elementClass->GetName();
if (elementClass == TClonesArray::Class()) {
ROOT::Internal::TTreeGeneratorBase ttreeGenerator(tbranch->GetTree(), "");
TString className = ttreeGenerator.GetContainedClassName((TBranchElement*)subbranch, tStreamerElement, pointer);
if (className != nullptr) {
TClass *otherClass = TClass::GetClass(className);
classesFromBranch(subbranch, otherClass, classes, variableWithArray.size() + 1, includes);
includes.insert("#include \"TClonesArray.h\"");
}
}
else if (elementClass->GetCollectionProxy() != nullptr && elementClass->GetCollectionProxy()->GetValueClass() != nullptr) {
TClass *otherClass = elementClass->GetCollectionProxy()->GetValueClass();
classesFromBranch(subbranch, otherClass, classes, variableWithArray.size() + 1, includes);
includes.insert(std::string("#include <") + type.substr(0, type.find('<')) + std::string(">"));
}
else
classesFromBranch(subbranch, elementClass, classes, variableWithArray.size() + 1, includes);
}
classStructure.members.push_back(MemberStructure(type, pointer, variable, variableWithArray, comment));
}
}
if (!classStructure.members.empty())
classes.push_back(classStructure);
}
}
}