From f5924774a2e8fc4d01d5d4be592629c5eb191f05 Mon Sep 17 00:00:00 2001
From: Philippe Canal <pcanal@fnal.gov>
Date: Tue, 19 Nov 2013 15:00:19 -0600
Subject: [PATCH] Always use ROOT::ESTLtype
---
core/meta/inc/TBaseClass.h | 14 +--
core/meta/src/TBaseClass.cxx | 24 ++---
core/meta/src/TClass.cxx | 2 +-
core/meta/src/TStreamerElement.cxx | 52 +++++------
core/metautils/inc/ESTLType.h | 1 +
core/metautils/inc/TClassEdit.h | 2 +-
core/metautils/inc/TMetaUtils.h | 11 ++-
core/metautils/src/RStl.cxx | 4 +-
core/metautils/src/TClassEdit.cxx | 32 +++----
core/metautils/src/TMetaUtils.cxx | 40 ++++-----
core/utils/src/rootcling.cxx | 22 ++---
io/io/src/TCollectionProxyFactory.cxx | 12 +--
io/io/src/TEmulatedCollectionProxy.cxx | 14 +--
io/io/src/TEmulatedMapProxy.cxx | 4 +-
io/io/src/TFile.cxx | 4 +-
io/io/src/TGenCollectionProxy.cxx | 86 +++++++++---------
io/io/src/TGenCollectionStreamer.cxx | 98 ++++++++++-----------
io/io/src/TMakeProject.cxx | 46 +++++-----
io/io/src/TStreamerInfo.cxx | 26 +++---
io/io/src/TStreamerInfoActions.cxx | 40 ++++-----
io/xml/src/TXMLPlayer.cxx | 20 ++---
tree/tree/src/TBranchElement.cxx | 54 ++++++------
tree/tree/src/TTree.cxx | 2 +-
tree/treeplayer/src/TTreeProxyGenerator.cxx | 24 ++---
tree/treeplayer/src/TTreeReaderArray.cxx | 4 +-
25 files changed, 321 insertions(+), 317 deletions(-)
diff --git a/core/meta/inc/TBaseClass.h b/core/meta/inc/TBaseClass.h
index 7fe119efd6d..b182648429f 100644
--- a/core/meta/inc/TBaseClass.h
+++ b/core/meta/inc/TBaseClass.h
@@ -46,13 +46,13 @@ private:
public:
TBaseClass(BaseClassInfo_t *info = 0, TClass *cl = 0);
virtual ~TBaseClass();
- virtual void Browse(TBrowser *b);
- const char *GetTitle() const;
- TClass *GetClassPointer(Bool_t load=kTRUE);
- Int_t GetDelta() const;
- Bool_t IsFolder() const {return kTRUE;}
- Int_t IsSTLContainer();
- Long_t Property() const;
+ virtual void Browse(TBrowser *b);
+ const char *GetTitle() const;
+ TClass *GetClassPointer(Bool_t load=kTRUE);
+ Int_t GetDelta() const;
+ Bool_t IsFolder() const {return kTRUE;}
+ ROOT::ESTLType IsSTLContainer();
+ Long_t Property() const;
ClassDef(TBaseClass,0) //Description of a base class
};
diff --git a/core/meta/src/TBaseClass.cxx b/core/meta/src/TBaseClass.cxx
index e99d60b7a18..b0c22793f3f 100644
--- a/core/meta/src/TBaseClass.cxx
+++ b/core/meta/src/TBaseClass.cxx
@@ -84,22 +84,22 @@ const char *TBaseClass::GetTitle() const
}
//______________________________________________________________________________
-int TBaseClass::IsSTLContainer()
+ROOT::ESTLType TBaseClass::IsSTLContainer()
{
// Return which type (if any) of STL container the data member is.
- if (!fInfo) return kNone;
+ if (!fInfo) return ROOT::kNotSTL;
const char *type = gCling->BaseClassInfo_TmpltName(fInfo);
- if (!type) return kNone;
-
- if (!strcmp(type, "vector")) return kVector;
- if (!strcmp(type, "list")) return kList;
- if (!strcmp(type, "deque")) return kDeque;
- if (!strcmp(type, "map")) return kMap;
- if (!strcmp(type, "multimap")) return kMultimap;
- if (!strcmp(type, "set")) return kSet;
- if (!strcmp(type, "multiset")) return kMultiset;
- return kNone;
+ if (!type) return ROOT::kNotSTL;
+
+ if (!strcmp(type, "vector")) return ROOT::kSTLvector;
+ if (!strcmp(type, "list")) return ROOT::kSTLlist;
+ if (!strcmp(type, "deque")) return ROOT::kSTLdeque;
+ if (!strcmp(type, "map")) return ROOT::kSTLmap;
+ if (!strcmp(type, "multimap")) return ROOT::kSTLmultimap;
+ if (!strcmp(type, "set")) return ROOT::kSTLset;
+ if (!strcmp(type, "multiset")) return ROOT::kSTLmultiset;
+ return ROOT::kNotSTL;
}
//______________________________________________________________________________
diff --git a/core/meta/src/TClass.cxx b/core/meta/src/TClass.cxx
index ebe1e0aa5aa..2078c26e531 100644
--- a/core/meta/src/TClass.cxx
+++ b/core/meta/src/TClass.cxx
@@ -1956,7 +1956,7 @@ Bool_t TClass::CanSplit() const
if (valueClass->GetCollectionProxy() != 0) return kFALSE;
Int_t stl = -TClassEdit::IsSTLCont(GetName(), 0);
- if ((stl==TClassEdit::kMap || stl==TClassEdit::kMultiMap)
+ if ((stl==ROOT::kSTLmap || stl==ROOT::kSTLmultimap)
&& valueClass->GetClassInfo()==0)
{
return kFALSE;
diff --git a/core/meta/src/TStreamerElement.cxx b/core/meta/src/TStreamerElement.cxx
index d54b2bab4f3..e8529882cb1 100644
--- a/core/meta/src/TStreamerElement.cxx
+++ b/core/meta/src/TStreamerElement.cxx
@@ -1570,7 +1570,7 @@ TStreamerSTL::TStreamerSTL() : fSTLtype(0),fCtype(0)
//______________________________________________________________________________
TStreamerSTL::TStreamerSTL(const char *name, const char *title, Int_t offset,
const char *typeName, const TVirtualCollectionProxy &proxy, Bool_t dmPointer)
- : TStreamerElement(name,title,offset,kSTL,typeName)
+ : TStreamerElement(name,title,offset,ROOT::kSTLany,typeName)
{
// Create a TStreamerSTL object.
@@ -1586,7 +1586,7 @@ TStreamerSTL::TStreamerSTL(const char *name, const char *title, Int_t offset,
if (dmPointer) fSTLtype += TVirtualStreamerInfo::kOffsetP;
- if (fSTLtype == kSTLbitset) {
+ if (fSTLtype == ROOT::kSTLbitset) {
// Nothing to check
} else if (proxy.GetValueClass()) {
if (proxy.HasPointers()) fCtype = TVirtualStreamerInfo::kObjectp;
@@ -1601,7 +1601,7 @@ TStreamerSTL::TStreamerSTL(const char *name, const char *title, Int_t offset,
//______________________________________________________________________________
TStreamerSTL::TStreamerSTL(const char *name, const char *title, Int_t offset,
const char *typeName, const char *trueType, Bool_t dmPointer)
- : TStreamerElement(name,title,offset,kSTL,typeName)
+ : TStreamerElement(name,title,offset,ROOT::kSTLany,typeName)
{
// Create a TStreamerSTL object.
@@ -1648,14 +1648,14 @@ TStreamerSTL::TStreamerSTL(const char *name, const char *title, Int_t offset,
fCtype = 0;
// Any class name that 'contains' the word will be counted
// as a STL container. Is that really what we want.
- if (strstr(s,"vector")) fSTLtype = kSTLvector;
- else if (strstr(s,"list")) fSTLtype = kSTLlist;
- else if (strstr(s,"deque")) fSTLtype = kSTLdeque;
- else if (strstr(s,"multimap")) fSTLtype = kSTLmultimap;
- else if (strstr(s,"multiset")) fSTLtype = kSTLmultiset;
- else if (strstr(s,"bitset")) fSTLtype = kSTLbitset;
- else if (strstr(s,"map")) fSTLtype = kSTLmap;
- else if (strstr(s,"set")) fSTLtype = kSTLset;
+ if (strstr(s,"vector")) fSTLtype = ROOT::kSTLvector;
+ else if (strstr(s,"list")) fSTLtype = ROOT::kSTLlist;
+ else if (strstr(s,"deque")) fSTLtype = ROOT::kSTLdeque;
+ else if (strstr(s,"multimap")) fSTLtype = ROOT::kSTLmultimap;
+ else if (strstr(s,"multiset")) fSTLtype = ROOT::kSTLmultiset;
+ else if (strstr(s,"bitset")) fSTLtype = ROOT::kSTLbitset;
+ else if (strstr(s,"map")) fSTLtype = ROOT::kSTLmap;
+ else if (strstr(s,"set")) fSTLtype = ROOT::kSTLset;
if (fSTLtype == 0) { delete [] s; return;}
if (dmPointer) fSTLtype += TVirtualStreamerInfo::kOffsetP;
@@ -1676,7 +1676,7 @@ TStreamerSTL::TStreamerSTL(const char *name, const char *title, Int_t offset,
TDataType *dt = (TDataType*)gROOT->GetListOfTypes()->FindObject(sopen);
- if (fSTLtype == kSTLbitset) {
+ if (fSTLtype == ROOT::kSTLbitset) {
// Nothing to check
} else if (dt) {
fCtype = dt->GetType();
@@ -1807,14 +1807,14 @@ const char *TStreamerSTL::GetInclude() const
{
// Return the proper include for this element.
- if (fSTLtype == kSTLvector) gIncludeName.Form("<%s>","vector");
- else if (fSTLtype == kSTLlist) gIncludeName.Form("<%s>","list");
- else if (fSTLtype == kSTLdeque) gIncludeName.Form("<%s>","deque");
- else if (fSTLtype == kSTLmap) gIncludeName.Form("<%s>","map");
- else if (fSTLtype == kSTLset) gIncludeName.Form("<%s>","set");
- else if (fSTLtype == kSTLmultimap) gIncludeName.Form("<%s>","map");
- else if (fSTLtype == kSTLmultiset) gIncludeName.Form("<%s>","set");
- else if (fSTLtype == kSTLbitset) gIncludeName.Form("<%s>","bitset");
+ if (fSTLtype == ROOT::kSTLvector) gIncludeName.Form("<%s>","vector");
+ else if (fSTLtype == ROOT::kSTLlist) gIncludeName.Form("<%s>","list");
+ else if (fSTLtype == ROOT::kSTLdeque) gIncludeName.Form("<%s>","deque");
+ else if (fSTLtype == ROOT::kSTLmap) gIncludeName.Form("<%s>","map");
+ else if (fSTLtype == ROOT::kSTLset) gIncludeName.Form("<%s>","set");
+ else if (fSTLtype == ROOT::kSTLmultimap) gIncludeName.Form("<%s>","map");
+ else if (fSTLtype == ROOT::kSTLmultiset) gIncludeName.Form("<%s>","set");
+ else if (fSTLtype == ROOT::kSTLbitset) gIncludeName.Form("<%s>","bitset");
return gIncludeName;
}
@@ -1844,15 +1844,15 @@ void TStreamerSTL::Streamer(TBuffer &R__b)
R__b >> fCtype;
R__b.CheckByteCount(R__s, R__c, TStreamerSTL::IsA());
}
- if (fSTLtype == kSTLmultimap || fSTLtype == kSTLset) {
+ if (fSTLtype == ROOT::kSTLmultimap || fSTLtype == ROOT::kSTLset) {
// For a long time those where inverted compared to the other
// definitions. When we move to version 'x', this got standardized,
// but we now need to fix it.
if (fTypeName.BeginsWith("std::set") || fTypeName.BeginsWith("set")) {
- fSTLtype = kSTLset;
+ fSTLtype = ROOT::kSTLset;
} else if (fTypeName.BeginsWith("std::multimap") || fTypeName.BeginsWith("multimap")) {
- fSTLtype = kSTLmultimap;
+ fSTLtype = ROOT::kSTLmultimap;
}
}
@@ -1864,7 +1864,7 @@ void TStreamerSTL::Streamer(TBuffer &R__b)
if (R__b.GetParent()) { // Avoid resetting during a cloning.
if (fCtype==TVirtualStreamerInfo::kObjectp || fCtype==TVirtualStreamerInfo::kAnyp || fCtype==TVirtualStreamerInfo::kObjectP || fCtype==TVirtualStreamerInfo::kAnyP) {
SetBit(kDoNotDelete); // For backward compatibility
- } else if ( fSTLtype == kSTLmap || fSTLtype == kSTLmultimap) {
+ } else if ( fSTLtype == ROOT::kSTLmap || fSTLtype == ROOT::kSTLmultimap) {
// Here we would like to set the bit only if one of the element of the pair is a pointer,
// however we have no easy to determine this short of parsing the class name.
SetBit(kDoNotDelete); // For backward compatibility
@@ -1915,8 +1915,8 @@ TStreamerSTLstring::TStreamerSTLstring(const char *name, const char *title, Int_
fNewType = fType;
fOffset = offset;
- fSTLtype = kSTLstring;
- fCtype = kSTLstring;
+ fSTLtype = ROOT::kSTLstring;
+ fCtype = ROOT::kSTLstring;
fTypeName= typeName;
}
diff --git a/core/metautils/inc/ESTLType.h b/core/metautils/inc/ESTLType.h
index 4b272078e0f..32a88095dd1 100644
--- a/core/metautils/inc/ESTLType.h
+++ b/core/metautils/inc/ESTLType.h
@@ -35,6 +35,7 @@ namespace ROOT {
kSTLset = 6,
kSTLmultiset = 7,
kSTLbitset = 8,
+ kSTLend = 9,
kSTLany = 300 /* TVirtualStreamerInfo::kSTL */,
kSTLstring = 365 /* TVirtualStreamerInfo::kSTLstring */
};
diff --git a/core/metautils/inc/TClassEdit.h b/core/metautils/inc/TClassEdit.h
index 8c7a368413b..ae1ff1afa9f 100644
--- a/core/metautils/inc/TClassEdit.h
+++ b/core/metautils/inc/TClassEdit.h
@@ -70,7 +70,7 @@ namespace TClassEdit {
kSet = ROOT::kSTLset,
kMultiSet = ROOT::kSTLmultiset,
kBitSet = ROOT::kSTLbitset,
- kEnd = 9
+ kEnd = ROOT::kSTLend
};
class TInterpreterLookupHelper {
diff --git a/core/metautils/inc/TMetaUtils.h b/core/metautils/inc/TMetaUtils.h
index 4e33ddde88f..8e193bbb358 100644
--- a/core/metautils/inc/TMetaUtils.h
+++ b/core/metautils/inc/TMetaUtils.h
@@ -47,7 +47,10 @@ namespace cling {
#include "cling/Utils/AST.h"
-// For TClassEdit::ESTLType and for TClassEdit::TInterpreterLookupHelper
+// For ROOT::ESTLType
+#include "ESTLType.h"
+
+// for TClassEdit::TInterpreterLookupHelper
#include "TClassEdit.h"
#ifndef ROOT_Varargs
@@ -338,7 +341,7 @@ int GetClassVersion(const clang::RecordDecl *cl);
int IsSTLContainer(const AnnotatedRecordDecl &annotated);
//______________________________________________________________________________
-TClassEdit::ESTLType IsSTLContainer(const clang::FieldDecl &m);
+ROOT::ESTLType IsSTLContainer(const clang::FieldDecl &m);
//______________________________________________________________________________
int IsSTLContainer(const clang::CXXBaseSpecifier &base);
@@ -523,7 +526,7 @@ bool IsStdClass(const clang::RecordDecl &cl);
//______________________________________________________________________________
// Return which kind of STL container the decl is, if any.
-TClassEdit::ESTLType IsSTLCont(const clang::RecordDecl &cl);
+ROOT::ESTLType IsSTLCont(const clang::RecordDecl &cl);
//______________________________________________________________________________
// Check if 'input' or any of its template parameter was substituted when
@@ -533,7 +536,7 @@ clang::QualType ReSubstTemplateArg(clang::QualType input, const clang::Type *ins
//______________________________________________________________________________
// Kind of stl container
-TClassEdit::ESTLType STLKind(const llvm::StringRef type);
+ROOT::ESTLType STLKind(const llvm::StringRef type);
//______________________________________________________________________________
// Set the toolchain and the include paths for the relocatability
diff --git a/core/metautils/src/RStl.cxx b/core/metautils/src/RStl.cxx
index 54d4a9b54ed..809d3726517 100644
--- a/core/metautils/src/RStl.cxx
+++ b/core/metautils/src/RStl.cxx
@@ -67,7 +67,7 @@ void ROOT::RStl::GenerateTClassFor(const clang::QualType &type, const cling::Int
ROOT::TMetaUtils::GetQualifiedName(*stlclass).c_str());
}
- if ( TClassEdit::STLKind( stlclass->getName().str().c_str() ) == TClassEdit::kVector ) {
+ if ( TClassEdit::STLKind( stlclass->getName().str().c_str() ) == ROOT::kSTLvector ) {
const clang::TemplateArgument &arg( templateCl->getTemplateArgs().get(0) );
if (arg.getKind() == clang::TemplateArgument::Type) {
const clang::NamedDecl *decl = arg.getAsType().getTypePtr()->getAsCXXRecordDecl();
@@ -122,7 +122,7 @@ void ROOT::RStl::GenerateTClassFor(const char *requestedName, const clang::CXXRe
}
- if ( TClassEdit::STLKind( stlclass->getName().str().c_str() ) == TClassEdit::kVector ) {
+ if ( TClassEdit::STLKind( stlclass->getName().str().c_str() ) == ROOT::kSTLvector ) {
const clang::TemplateArgument &arg( templateCl->getTemplateArgs().get(0) );
if (arg.getKind() == clang::TemplateArgument::Type) {
const clang::NamedDecl *decl = arg.getAsType().getTypePtr()->getAsCXXRecordDecl();
diff --git a/core/metautils/src/TClassEdit.cxx b/core/metautils/src/TClassEdit.cxx
index d0c32a60c23..3079a89165b 100644
--- a/core/metautils/src/TClassEdit.cxx
+++ b/core/metautils/src/TClassEdit.cxx
@@ -57,7 +57,7 @@ int TClassEdit::TSplitType::IsSTLCont(int testAlloc) const
int kind = STLKind(fElements[0].c_str());
- if (kind==kVector || kind==kList ) {
+ if (kind==ROOT::kSTLvector || kind==ROOT::kSTLlist ) {
int nargs = STLArgs(kind);
if (testAlloc && (numb-1 > nargs) && !IsDefAlloc(fElements[numb-1].c_str(),fElements[1].c_str())) {
@@ -157,15 +157,15 @@ void TClassEdit::TSplitType::ShortType(std::string &answ, int mode)
} else if (mode & kDropDefaultAlloc) {
switch (kind) {
- case kVector:
- case kList:
- case kDeque:
- case kSet:
- case kMultiSet:
+ case ROOT::kSTLvector:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
dropAlloc = IsDefAlloc(fElements[iall+1].c_str(),fElements[1].c_str());
break;
- case kMap:
- case kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
dropAlloc = IsDefAlloc(fElements[iall+1].c_str(),fElements[1].c_str(),fElements[2].c_str());
break;
default:
@@ -190,14 +190,14 @@ void TClassEdit::TSplitType::ShortType(std::string &answ, int mode)
} else if ( mode & kDropComparator ) {
switch (kind) {
- case kVector:
- case kList:
- case kDeque:
+ case ROOT::kSTLvector:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
break;
- case kSet:
- case kMultiSet:
- case kMap:
- case kMultiMap:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
if (!allocRemoved && narg-1 == iall+1) {
narg--;
allocRemoved = true;
@@ -794,7 +794,7 @@ bool TClassEdit::IsStdClass(const char *classname)
bool TClassEdit::IsVectorBool(const char *name) {
TSplitType splitname( name );
- return ( TClassEdit::STLKind( splitname.fElements[0].c_str() ) == TClassEdit::kVector)
+ return ( TClassEdit::STLKind( splitname.fElements[0].c_str() ) == ROOT::kSTLvector)
&& ( splitname.fElements[1] == "bool" || splitname.fElements[1]=="Bool_t");
}
diff --git a/core/metautils/src/TMetaUtils.cxx b/core/metautils/src/TMetaUtils.cxx
index b45efd177dd..67055dd82dd 100644
--- a/core/metautils/src/TMetaUtils.cxx
+++ b/core/metautils/src/TMetaUtils.cxx
@@ -1894,17 +1894,17 @@ void ROOT::TMetaUtils::WriteClassInit(std::ostream& finalString,
int stlType = (idx!=(int)std::string::npos) ? TClassEdit::STLKind(classname.substr(0,idx).c_str()) : 0;
const char* methodTCP=0;
switch(stlType) {
- case TClassEdit::kVector:
- case TClassEdit::kList:
- case TClassEdit::kDeque:
+ case ROOT::kSTLvector:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
methodTCP="Pushback";
break;
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
methodTCP="MapInsert";
break;
- case TClassEdit::kSet:
- case TClassEdit::kMultiSet:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
methodTCP="Insert";
break;
}
@@ -2533,7 +2533,7 @@ int ROOT::TMetaUtils::IsSTLContainer(const ROOT::TMetaUtils::AnnotatedRecordDecl
}
//______________________________________________________________________________
-TClassEdit::ESTLType ROOT::TMetaUtils::IsSTLContainer(const clang::FieldDecl &m)
+ROOT::ESTLType ROOT::TMetaUtils::IsSTLContainer(const clang::FieldDecl &m)
{
// Is this an STL container?
@@ -2541,7 +2541,7 @@ TClassEdit::ESTLType ROOT::TMetaUtils::IsSTLContainer(const clang::FieldDecl &m)
clang::RecordDecl *decl = ROOT::TMetaUtils::GetUnderlyingRecordDecl(type);
if (decl) return TMetaUtils::IsSTLCont(*decl);
- else return TClassEdit::kNotSTL;
+ else return ROOT::kNotSTL;
}
//______________________________________________________________________________
@@ -2553,7 +2553,7 @@ int ROOT::TMetaUtils::IsSTLContainer(const clang::CXXBaseSpecifier &base)
clang::RecordDecl *decl = ROOT::TMetaUtils::GetUnderlyingRecordDecl(type);
if (decl) return TMetaUtils::IsSTLCont(*decl);
- else return TClassEdit::kNotSTL;
+ else return ROOT::kNotSTL;
}
//______________________________________________________________________________
@@ -3773,7 +3773,7 @@ bool ROOT::TMetaUtils::IsStdClass(const clang::RecordDecl &cl)
}
//______________________________________________________________________________
-TClassEdit::ESTLType ROOT::TMetaUtils::IsSTLCont(const clang::RecordDecl &cl)
+ROOT::ESTLType ROOT::TMetaUtils::IsSTLCont(const clang::RecordDecl &cl)
{
// type : type name: vector<list<classA,allocator>,allocator>
// result: 0 : not stl container
@@ -3792,7 +3792,7 @@ TClassEdit::ESTLType ROOT::TMetaUtils::IsSTLCont(const clang::RecordDecl &cl)
// For example: vector<deque<int>> has answer -1
if (!IsStdClass(cl)) {
- return TClassEdit::kNotSTL;
+ return ROOT::kNotSTL;
}
return STLKind(cl.getName());
@@ -3918,22 +3918,22 @@ clang::QualType ROOT::TMetaUtils::ReSubstTemplateArg(clang::QualType input, cons
}
//______________________________________________________________________________
-TClassEdit::ESTLType ROOT::TMetaUtils::STLKind(const llvm::StringRef type)
+ROOT::ESTLType ROOT::TMetaUtils::STLKind(const llvm::StringRef type)
{
// Converts STL container name to number. vector -> 1, etc..
static const char *stls[] = //container names
{"any","vector","list","deque","map","multimap","set","multiset","bitset",0};
- static const TClassEdit::ESTLType values[] =
- {TClassEdit::kNotSTL, TClassEdit::kVector,
- TClassEdit::kList, TClassEdit::kDeque,
- TClassEdit::kMap, TClassEdit::kMultiMap,
- TClassEdit::kSet, TClassEdit::kMultiSet,
- TClassEdit::kBitSet, TClassEdit::kEnd
+ static const ROOT::ESTLType values[] =
+ {ROOT::kNotSTL, ROOT::kSTLvector,
+ ROOT::kSTLlist, ROOT::kSTLdeque,
+ ROOT::kSTLmap, ROOT::kSTLmultimap,
+ ROOT::kSTLset, ROOT::kSTLmultiset,
+ ROOT::kSTLbitset, ROOT::kNotSTL
};
// kind of stl container
for(int k=1;stls[k];k++) {if (type.equals(stls[k])) return values[k];}
- return TClassEdit::kNotSTL;
+ return ROOT::kNotSTL;
}
//______________________________________________________________________________
diff --git a/core/utils/src/rootcling.cxx b/core/utils/src/rootcling.cxx
index cb71d94fcd2..f73cdf427a9 100644
--- a/core/utils/src/rootcling.cxx
+++ b/core/utils/src/rootcling.cxx
@@ -1027,7 +1027,7 @@ int STLContainerStreamer(const clang::FieldDecl &m,
tcl1="R__tcl1";
fulName1 = ti.getAsString(); // Should we be passing a context?
}
- if (stltype==kMap || stltype==kMultiMap) {
+ if (stltype==kSTLmap || stltype==kSTLmultimap) {
const clang::TemplateArgument &arg1( tmplt_specialization->getTemplateArgs().get(1) );
clang::QualType tmplti = arg1.getAsType();
if (ROOT::TMetaUtils::ElementStreamer(*dictSrcOut, m, tmplti, 0, rwmode, interp)) {
@@ -1102,13 +1102,13 @@ int STLContainerStreamer(const clang::FieldDecl &m,
(*dictSrcOut) << " int R__i, R__n;" << std::endl
<< " R__b >> R__n;" << std::endl;
- if (stltype==kVector) {
+ if (stltype==kSTLvector) {
(*dictSrcOut) << " R__stl.reserve(R__n);" << std::endl;
}
(*dictSrcOut) << " for (R__i = 0; R__i < R__n; R__i++) {" << std::endl;
ROOT::TMetaUtils::ElementStreamer(*dictSrcOut, m, arg0.getAsType(), "R__t", rwmode, interp, tcl1);
- if (stltype == kMap || stltype == kMultiMap) { //Second Arg
+ if (stltype == kSTLmap || stltype == kSTLmultimap) { //Second Arg
const clang::TemplateArgument &arg1( tmplt_specialization->getTemplateArgs().get(1) );
ROOT::TMetaUtils::ElementStreamer(*dictSrcOut, m, arg1.getAsType(), "R__t2", rwmode, interp, tcl2);
}
@@ -1125,8 +1125,8 @@ int STLContainerStreamer(const clang::FieldDecl &m,
*/
switch (stltype) {
- case kMap:
- case kMultiMap: {
+ case kSTLmap:
+ case kSTLmultimap: {
std::string keyName( ti.getAsString() );
(*dictSrcOut) << " typedef " << keyName << " Value_t;" << std::endl
<< " std::pair<Value_t const, " << tmplt_specialization->getTemplateArgs().get(1).getAsType().getAsString() << " > R__t3(R__t,R__t2);" << std::endl
@@ -1134,13 +1134,13 @@ int STLContainerStreamer(const clang::FieldDecl &m,
//fprintf(fp, " R__stl.insert(%s::value_type(R__t,R__t2));\n",stlType.c_str());
break;
}
- case kSet:
- case kMultiSet:
+ case kSTLset:
+ case kSTLmultiset:
(*dictSrcOut) << " R__stl.insert(R__t);" << std::endl;
break;
- case kVector:
- case kList:
- case kDeque:
+ case kSTLvector:
+ case kSTLlist:
+ case kSTLdeque:
(*dictSrcOut) << " R__stl.push_back(R__t);" << std::endl;
break;
@@ -1195,7 +1195,7 @@ int STLContainerStreamer(const clang::FieldDecl &m,
(*dictSrcOut) << " " << stlType.c_str() << "::iterator R__k;" << std::endl
<< " for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {" << std::endl;
- if (stltype == kMap || stltype == kMultiMap) {
+ if (stltype == kSTLmap || stltype == kSTLmultimap) {
const clang::TemplateArgument &arg1( tmplt_specialization->getTemplateArgs().get(1) );
clang::QualType tmplti = arg1.getAsType();
ROOT::TMetaUtils::ElementStreamer(*dictSrcOut, m, ti, "((*R__k).first )",rwmode,interp, tcl1);
diff --git a/io/io/src/TCollectionProxyFactory.cxx b/io/io/src/TCollectionProxyFactory.cxx
index 1d8f3116f08..46aa1b821c5 100644
--- a/io/io/src/TCollectionProxyFactory.cxx
+++ b/io/io/src/TCollectionProxyFactory.cxx
@@ -37,15 +37,15 @@
// Do not clutter global namespace with shit....
namespace {
- static TClassEdit::ESTLType stl_type(const std::string& class_name) {
+ static ROOT::ESTLType stl_type(const std::string& class_name) {
// return the STL type.
int nested = 0;
std::vector<std::string> inside;
int num = TClassEdit::GetSplit(class_name.c_str(),inside,nested);
if ( num > 1 ) {
- return (TClassEdit::ESTLType)TClassEdit::STLKind(inside[0].c_str());
+ return (ROOT::ESTLType)TClassEdit::STLKind(inside[0].c_str());
}
- return TClassEdit::kNotSTL;
+ return ROOT::kNotSTL;
}
static TEmulatedCollectionProxy* GenEmulation(const char* class_name, Bool_t silent) {
@@ -59,10 +59,10 @@ namespace {
cl.replace(0,16,"std::");
TEmulatedCollectionProxy * result = 0;
switch ( stl_type(cl) ) {
- case TClassEdit::kNotSTL:
+ case ROOT::kNotSTL:
return 0;
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
result = new TEmulatedMapProxy(class_name,silent);
break;
default:
diff --git a/io/io/src/TEmulatedCollectionProxy.cxx b/io/io/src/TEmulatedCollectionProxy.cxx
index 0f82ffc19ea..9eb96e53f88 100644
--- a/io/io/src/TEmulatedCollectionProxy.cxx
+++ b/io/io/src/TEmulatedCollectionProxy.cxx
@@ -138,8 +138,8 @@ TGenCollectionProxy *TEmulatedCollectionProxy::InitializeEx(Bool_t silent)
// std::cout << "Initialized " << typeid(*this).name() << ":" << fName << std::endl;
int slong = sizeof(void*);
switch ( fSTL_type ) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
nam = "pair<"+inside[1]+","+inside[2];
nam += (nam[nam.length()-1]=='>') ? " >" : ">";
if (0==TClass::GetClass(nam.c_str())) {
@@ -166,7 +166,7 @@ TGenCollectionProxy *TEmulatedCollectionProxy::InitializeEx(Bool_t silent)
fValOffset += (slong - fKey->fSize%slong)%slong;
}
break;
- case TClassEdit::kBitSet:
+ case ROOT::kSTLbitset:
inside[1] = "bool";
// Intentional fall through
default:
@@ -229,8 +229,8 @@ void TEmulatedCollectionProxy::Shrink(UInt_t nCurr, UInt_t left, Bool_t force )
size_t i;
switch ( fSTL_type ) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
addr = ((char*)fEnv->fStart) + fValDiff*left;
switch(fKey->fCase) {
case kIsFundamental: // Only handle primitives this way
@@ -335,8 +335,8 @@ void TEmulatedCollectionProxy::Expand(UInt_t nCurr, UInt_t left)
char* addr = ((char*)fEnv->fStart) + fValDiff*nCurr;
switch ( fSTL_type ) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
switch(fKey->fCase) {
case kIsFundamental: // Only handle primitives this way
case kIsEnum:
diff --git a/io/io/src/TEmulatedMapProxy.cxx b/io/io/src/TEmulatedMapProxy.cxx
index 1f6216c9f37..3cbc46ca1ac 100644
--- a/io/io/src/TEmulatedMapProxy.cxx
+++ b/io/io/src/TEmulatedMapProxy.cxx
@@ -32,7 +32,7 @@ TEmulatedMapProxy::TEmulatedMapProxy(const TEmulatedMapProxy& copy)
: TEmulatedCollectionProxy(copy)
{
// copy constructor
- if ( !(fSTL_type == TClassEdit::kMap || fSTL_type == TClassEdit::kMultiMap) ) {
+ if ( !(fSTL_type == ROOT::kSTLmap || fSTL_type == ROOT::kSTLmultimap) ) {
Fatal("TEmulatedMapProxy","Class %s is not a map-type!",fName.c_str());
}
}
@@ -41,7 +41,7 @@ TEmulatedMapProxy::TEmulatedMapProxy(const char* cl_name, Bool_t silent)
: TEmulatedCollectionProxy(cl_name, silent)
{
// Build a Streamer for an emulated vector whose type is 'name'.
- if ( !(fSTL_type == TClassEdit::kMap || fSTL_type == TClassEdit::kMultiMap) ) {
+ if ( !(fSTL_type == ROOT::kSTLmap || fSTL_type == ROOT::kSTLmultimap) ) {
Fatal("TEmulatedMapProxy","Class %s is not a map-type!",fName.c_str());
}
}
diff --git a/io/io/src/TFile.cxx b/io/io/src/TFile.cxx
index 4c91e88ae17..ece64222799 100644
--- a/io/io/src/TFile.cxx
+++ b/io/io/src/TFile.cxx
@@ -2835,8 +2835,8 @@ void TFile::MakeProject(const char *dirname, const char * /*classes*/,
if (key) {
TString what;
switch ( stlkind ) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
if (TClass::GetClass(inside[1].c_str())) {
what = "std::pair<";
what += TMakeProject::UpdateAssociativeToVector( inside[1].c_str() );
diff --git a/io/io/src/TGenCollectionProxy.cxx b/io/io/src/TGenCollectionProxy.cxx
index 32c84d7f86e..4aba2bf355b 100644
--- a/io/io/src/TGenCollectionProxy.cxx
+++ b/io/io/src/TGenCollectionProxy.cxx
@@ -567,7 +567,7 @@ TGenCollectionProxy::TGenCollectionProxy(Info_t info, size_t iter_size)
fValDiff = 0;
fPointers = false;
fOnFileClass = 0;
- fSTL_type = TClassEdit::kNotSTL;
+ fSTL_type = ROOT::kNotSTL;
Env_t e;
if ( iter_size > sizeof(e.fIterator) ) {
Fatal("TGenCollectionProxy",
@@ -616,7 +616,7 @@ TGenCollectionProxy::TGenCollectionProxy(const ROOT::TCollectionProxyInfo &info,
fKey = 0;
fVal = 0;
fPointers = false;
- fSTL_type = TClassEdit::kNotSTL;
+ fSTL_type = ROOT::kNotSTL;
Env_t e;
if ( info.fIterSize > sizeof(e.fIterator) ) {
@@ -687,23 +687,23 @@ TVirtualCollectionProxy* TGenCollectionProxy::Generate() const
return new TGenCollectionProxy(*this);
switch(fSTL_type) {
- case TClassEdit::kBitSet: {
+ case ROOT::kSTLbitset: {
return new TGenBitsetProxy(*this);
}
- case TClassEdit::kVector: {
+ case ROOT::kSTLvector: {
if (fValue->fKind == (EDataType)kBOOL_t) {
return new TGenVectorBoolProxy(*this);
} else {
return new TGenVectorProxy(*this);
}
}
- case TClassEdit::kList:
+ case ROOT::kSTLlist:
return new TGenListProxy(*this);
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
return new TGenMapProxy(*this);
- case TClassEdit::kSet:
- case TClassEdit::kMultiSet:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
return new TGenSetProxy(*this);
default:
return new TGenCollectionProxy(*this);
@@ -790,19 +790,19 @@ TGenCollectionProxy *TGenCollectionProxy::InitializeEx(Bool_t silent)
inside[0].replace(0,16,"std::");
fSTL_type = TClassEdit::STLKind(inside[0].c_str());
switch ( fSTL_type ) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
- case TClassEdit::kSet:
- case TClassEdit::kMultiSet:
- case TClassEdit::kBitSet: // not really an associate container but it has no real iterator.
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLbitset: // not really an associate container but it has no real iterator.
fProperties |= kIsAssociative;
break;
};
int slong = sizeof(void*);
switch ( fSTL_type ) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
nam = "pair<"+inside[1]+","+inside[2];
nam += (nam[nam.length()-1]=='>') ? " >" : ">";
fValue = R__CreateValue(nam, silent);
@@ -823,7 +823,7 @@ TGenCollectionProxy *TGenCollectionProxy::InitializeEx(Bool_t silent)
fValOffset += (slong - fKey->fSize%slong)%slong;
}
break;
- case TClassEdit::kBitSet:
+ case ROOT::kSTLbitset:
inside[1] = "bool";
// Intentional fall through
default:
@@ -897,7 +897,7 @@ Bool_t TGenCollectionProxy::HasPointers() const
// The content of a map and multimap is always a 'pair' and hence
// fPointers means "Flag to indicate if containee has pointers (key or value)"
// so we need to ignore its value for map and multimap;
- return fPointers && !(fSTL_type == TClassEdit::kMap || fSTL_type == TClassEdit::kMultiMap);
+ return fPointers && !(fSTL_type == ROOT::kSTLmap || fSTL_type == ROOT::kSTLmultimap);
}
//______________________________________________________________________________
@@ -933,7 +933,7 @@ void* TGenCollectionProxy::At(UInt_t idx)
// Return the address of the value at index 'idx'
if ( fEnv && fEnv->fObject ) {
switch (fSTL_type) {
- case TClassEdit::kVector:
+ case ROOT::kSTLvector:
fEnv->fIdx = idx;
switch( idx ) {
case 0:
@@ -942,10 +942,10 @@ void* TGenCollectionProxy::At(UInt_t idx)
if (! fEnv->fStart ) fEnv->fStart = fFirst.invoke(fEnv);
return ((char*)fEnv->fStart) + fValDiff*idx;
}
- case TClassEdit::kSet:
- case TClassEdit::kMultiSet:
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
if ( fEnv->fUseTemp ) {
return (((char*)fEnv->fTemp)+idx*fValDiff);
}
@@ -1029,10 +1029,10 @@ void* TGenCollectionProxy::Allocate(UInt_t n, Bool_t /* forceDelete */ )
if ( fEnv && fEnv->fObject ) {
switch ( fSTL_type ) {
- case TClassEdit::kSet:
- case TClassEdit::kMultiSet:
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap: {
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap: {
if ( (fProperties & kNeedDelete) )
Clear("force");
else
@@ -1060,9 +1060,9 @@ void* TGenCollectionProxy::Allocate(UInt_t n, Bool_t /* forceDelete */ )
return s;
}
- case TClassEdit::kVector:
- case TClassEdit::kList:
- case TClassEdit::kDeque:
+ case ROOT::kSTLvector:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
if( (fProperties & kNeedDelete) ) {
Clear("force");
}
@@ -1070,7 +1070,7 @@ void* TGenCollectionProxy::Allocate(UInt_t n, Bool_t /* forceDelete */ )
fResize(fEnv->fObject,n);
return fEnv->fObject;
- case TClassEdit::kBitSet: {
+ case ROOT::kSTLbitset: {
TStaging *s;
if (fStaged.empty()) {
s = new TStaging(n,fValDiff);
@@ -1098,10 +1098,10 @@ void TGenCollectionProxy::Commit(void* from)
// Commit the change.
if (fProperties & kIsAssociative) {
-// case TClassEdit::kMap:
-// case TClassEdit::kMultiMap:
-// case TClassEdit::kSet:
-// case TClassEdit::kMultiSet:
+// case ROOT::kSTLmap:
+// case ROOT::kSTLmultimap:
+// case ROOT::kSTLset:
+// case ROOT::kSTLmultiset:
if ( from ) {
TStaging *s = (TStaging*) from;
if ( s->GetTarget() ) {
@@ -1171,8 +1171,8 @@ void TGenCollectionProxy::DeleteItem(Bool_t force, void* ptr) const
// Call to delete/destruct individual item.
if ( force && ptr ) {
switch (fSTL_type) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap: {
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap: {
if ( fKey->fCase&kIsPointer ) {
if (fKey->fProperties&kNeedDelete) {
TVirtualCollectionProxy *proxy = fKey->fType->GetCollectionProxy();
@@ -1415,14 +1415,14 @@ TVirtualCollectionProxy::CreateIterators_t TGenCollectionProxy::GetFunctionCreat
if ( !fValue ) InitializeEx(kFALSE);
// fprintf(stderr,"GetFunctinCreateIterator for %s will give: ",fClass.GetClassName());
-// if (fSTL_type==TClassEdit::kVector || (fProperties & kIsEmulated))
+// if (fSTL_type==ROOT::kSTLvector || (fProperties & kIsEmulated))
// fprintf(stderr,"vector/emulated iterator\n");
// else if ( (fProperties & kIsAssociative) && read)
// fprintf(stderr,"an associative read iterator\n");
// else
// fprintf(stderr,"a generic iterator\n");
- if (fSTL_type==TClassEdit::kVector || (fProperties & kIsEmulated))
+ if (fSTL_type==ROOT::kSTLvector || (fProperties & kIsEmulated))
return fFunctionCreateIterators = TGenCollectionProxy__VectorCreateIterators;
else if ( (fProperties & kIsAssociative) && read)
return TGenCollectionProxy__StagingCreateIterators;
@@ -1448,7 +1448,7 @@ TVirtualCollectionProxy::CopyIterator_t TGenCollectionProxy::GetFunctionCopyIter
if ( !fValue ) InitializeEx(kFALSE);
- if (fSTL_type==TClassEdit::kVector || (fProperties & kIsEmulated))
+ if (fSTL_type==ROOT::kSTLvector || (fProperties & kIsEmulated))
return fFunctionCopyIterator = TGenCollectionProxy__VectorCopyIterator;
else if ( (fProperties & kIsAssociative) && read)
return TGenCollectionProxy__StagingCopyIterator;
@@ -1475,7 +1475,7 @@ TVirtualCollectionProxy::Next_t TGenCollectionProxy::GetFunctionNext(Bool_t read
if ( !fValue ) InitializeEx(kFALSE);
- if (fSTL_type==TClassEdit::kVector || (fProperties & kIsEmulated))
+ if (fSTL_type==ROOT::kSTLvector || (fProperties & kIsEmulated))
return fFunctionNextIterator = TGenCollectionProxy__VectorNext;
else if ( (fProperties & kIsAssociative) && read)
return TGenCollectionProxy__StagingNext;
@@ -1500,7 +1500,7 @@ TVirtualCollectionProxy::DeleteIterator_t TGenCollectionProxy::GetFunctionDelete
if ( !fValue ) InitializeEx(kFALSE);
- if (fSTL_type==TClassEdit::kVector || (fProperties & kIsEmulated))
+ if (fSTL_type==ROOT::kSTLvector || (fProperties & kIsEmulated))
return fFunctionDeleteIterator = TGenCollectionProxy__VectorDeleteSingleIterators;
else if ( (fProperties & kIsAssociative) && read)
return TGenCollectionProxy__StagingDeleteSingleIterators;
@@ -1525,7 +1525,7 @@ TVirtualCollectionProxy::DeleteTwoIterators_t TGenCollectionProxy::GetFunctionDe
if ( !fValue ) InitializeEx(kFALSE);
- if (fSTL_type==TClassEdit::kVector || (fProperties & kIsEmulated))
+ if (fSTL_type==ROOT::kSTLvector || (fProperties & kIsEmulated))
return fFunctionDeleteTwoIterators = TGenCollectionProxy__VectorDeleteTwoIterators;
else if ( (fProperties & kIsAssociative) && read)
return TGenCollectionProxy__StagingDeleteTwoIterators;
diff --git a/io/io/src/TGenCollectionStreamer.cxx b/io/io/src/TGenCollectionStreamer.cxx
index 71e026f521b..45269ad10c5 100644
--- a/io/io/src/TGenCollectionStreamer.cxx
+++ b/io/io/src/TGenCollectionStreamer.cxx
@@ -224,7 +224,7 @@ void TGenCollectionStreamer::ReadPrimitives(int nElements, TBuffer &b, const TCl
StreamHelper* itmconv = 0;
fEnv->fSize = nElements;
switch (fSTL_type) {
- case TClassEdit::kVector:
+ case ROOT::kSTLvector:
if (fVal->fKind != EDataType(kBOOL_t)) {
fResize(fEnv->fObject,fEnv->fSize);
fEnv->fIdx = 0;
@@ -385,7 +385,7 @@ void TGenCollectionStreamer::ReadObjects(int nElements, TBuffer &b, const TClass
fEnv->fSize = nElements;
switch (fSTL_type) {
// Simple case: contiguous memory. get address of first, then jump.
- case TClassEdit::kVector:
+ case ROOT::kSTLvector:
#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)(((char*)itm) + fValDiff*idx); { x ;} ++idx;} break;}
fResize(fEnv->fObject,fEnv->fSize);
fEnv->fIdx = 0;
@@ -413,8 +413,8 @@ void TGenCollectionStreamer::ReadObjects(int nElements, TBuffer &b, const TClass
// No contiguous memory, but resize is possible
// Hence accessing objects using At(i) should be not too much an overhead
- case TClassEdit::kList:
- case TClassEdit::kDeque:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)TGenCollectionProxy::At(idx); { x ;} ++idx;} break;}
fResize(fEnv->fObject,fEnv->fSize);
fEnv->fIdx = 0;
@@ -436,8 +436,8 @@ void TGenCollectionStreamer::ReadObjects(int nElements, TBuffer &b, const TClass
// Rather troublesome case: Objects can only be fed into the container
// Once they are created. Need to take memory from stack or heap.
- case TClassEdit::kMultiSet:
- case TClassEdit::kSet:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLset:
#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)(((char*)itm) + fValDiff*idx); { x ;} ++idx;}}
fEnv->fStart = itm = (StreamHelper*)(len < sizeof(buffer) ? buffer : memory =::operator new(len));
fConstruct(itm,nElements);
@@ -499,7 +499,7 @@ void TGenCollectionStreamer::ReadPairFromMap(int nElements, TBuffer &b)
fEnv->fSize = nElements;
switch (fSTL_type) {
// Simple case: contiguous memory. get address of first, then jump.
- case TClassEdit::kVector:
+ case ROOT::kSTLvector:
#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)(((char*)itm) + fValDiff*idx); { x ;} ++idx;} break;}
fResize(fEnv->fObject,fEnv->fSize);
fEnv->fIdx = 0;
@@ -522,8 +522,8 @@ void TGenCollectionStreamer::ReadPairFromMap(int nElements, TBuffer &b)
// No contiguous memory, but resize is possible
// Hence accessing objects using At(i) should be not too much an overhead
- case TClassEdit::kList:
- case TClassEdit::kDeque:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)TGenCollectionProxy::At(idx); { x ;} ++idx;} break;}
fResize(fEnv->fObject,fEnv->fSize);
fEnv->fIdx = 0;
@@ -544,8 +544,8 @@ void TGenCollectionStreamer::ReadPairFromMap(int nElements, TBuffer &b)
// Rather troublesome case: Objects can only be fed into the container
// Once they are created. Need to take memory from stack or heap.
- case TClassEdit::kMultiSet:
- case TClassEdit::kSet:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLset:
#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)(((char*)itm) + fValDiff*idx); { x ;} ++idx;}}
fEnv->fStart = itm = (StreamHelper*)(len < sizeof(buffer) ? buffer : memory =::operator new(len));
fConstruct(itm,nElements);
@@ -915,7 +915,7 @@ void TGenCollectionStreamer::WritePrimitives(int nElements, TBuffer &b)
void* memory = 0;
StreamHelper* itm = 0;
switch (fSTL_type) {
- case TClassEdit::kVector:
+ case ROOT::kSTLvector:
if (fVal->fKind != EDataType(kBOOL_t)) {
itm = (StreamHelper*)(fEnv->fStart = fFirst.invoke(fEnv));
break;
@@ -990,7 +990,7 @@ void TGenCollectionStreamer::WriteObjects(int nElements, TBuffer &b)
StreamHelper* itm = 0;
switch (fSTL_type) {
// Simple case: contiguous memory. get address of first, then jump.
- case TClassEdit::kVector:
+ case ROOT::kSTLvector:
#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)(((char*)itm) + fValDiff*idx); { x ;} ++idx;} break;}
itm = (StreamHelper*)fFirst.invoke(fEnv);
switch (fVal->fCase) {
@@ -1015,10 +1015,10 @@ void TGenCollectionStreamer::WriteObjects(int nElements, TBuffer &b)
// No contiguous memory, but resize is possible
// Hence accessing objects using At(i) should be not too much an overhead
- case TClassEdit::kList:
- case TClassEdit::kDeque:
- case TClassEdit::kMultiSet:
- case TClassEdit::kSet:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLset:
#define DOLOOP(x) {int idx=0; while(idx<nElements) {StreamHelper* i=(StreamHelper*)TGenCollectionProxy::At(idx); { x ;} ++idx;} break;}
switch (fVal->fCase) {
case kIsClass:
@@ -1263,7 +1263,7 @@ void TGenCollectionStreamer::ReadBufferDefault(TBuffer &b, void *obj, const TCla
if (!GetFunctionCreateIterators()) {
Fatal("TGenCollectionStreamer::ReadBufferDefault","No CreateIterators function for %s",fName.c_str());
}
- if (fSTL_type == TClassEdit::kVector && ( fVal->fCase == kIsFundamental || fVal->fCase == kIsEnum ) )
+ if (fSTL_type == ROOT::kSTLvector && ( fVal->fCase == kIsFundamental || fVal->fCase == kIsEnum ) )
{
// Only handle primitives this way
switch (int(fVal->fKind)) {
@@ -1338,7 +1338,7 @@ void TGenCollectionStreamer::ReadBufferGeneric(TBuffer &b, void *obj, const TCla
}
} else if (nElements > 0) {
switch (fSTL_type) {
- case TClassEdit::kBitSet:
+ case ROOT::kSTLbitset:
if (obj) {
if (fProperties & kNeedDelete) {
TGenCollectionProxy::Clear("force");
@@ -1348,7 +1348,7 @@ void TGenCollectionStreamer::ReadBufferGeneric(TBuffer &b, void *obj, const TCla
}
ReadPrimitives(nElements, b, onFileClass);
return;
- case TClassEdit::kVector:
+ case ROOT::kSTLvector:
if (obj) {
if (fProperties & kNeedDelete) {
TGenCollectionProxy::Clear("force");
@@ -1367,10 +1367,10 @@ void TGenCollectionStreamer::ReadBufferGeneric(TBuffer &b, void *obj, const TCla
return;
}
break;
- case TClassEdit::kList:
- case TClassEdit::kDeque:
- case TClassEdit::kMultiSet:
- case TClassEdit::kSet:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLset:
if (obj) {
if (fProperties & kNeedDelete) {
TGenCollectionProxy::Clear("force");
@@ -1388,8 +1388,8 @@ void TGenCollectionStreamer::ReadBufferGeneric(TBuffer &b, void *obj, const TCla
return;
}
break;
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
if (obj) {
if (fProperties & kNeedDelete) {
TGenCollectionProxy::Clear("force");
@@ -1414,14 +1414,14 @@ void TGenCollectionStreamer::Streamer(TBuffer &b)
}
if (nElements > 0) {
switch (fSTL_type) {
- case TClassEdit::kBitSet:
+ case ROOT::kSTLbitset:
ReadPrimitives(nElements, b, fOnFileClass);
return;
- case TClassEdit::kVector:
- case TClassEdit::kList:
- case TClassEdit::kDeque:
- case TClassEdit::kMultiSet:
- case TClassEdit::kSet:
+ case ROOT::kSTLvector:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLset:
switch (fVal->fCase) {
case kIsFundamental: // Only handle primitives this way
case kIsEnum:
@@ -1432,8 +1432,8 @@ void TGenCollectionStreamer::Streamer(TBuffer &b)
return;
}
break;
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
ReadMap(nElements, b, fOnFileClass);
break;
}
@@ -1443,14 +1443,14 @@ void TGenCollectionStreamer::Streamer(TBuffer &b)
b << nElements;
if (nElements > 0) {
switch (fSTL_type) {
- case TClassEdit::kBitSet:
+ case ROOT::kSTLbitset:
WritePrimitives(nElements, b);
return;
- case TClassEdit::kVector:
- case TClassEdit::kList:
- case TClassEdit::kDeque:
- case TClassEdit::kMultiSet:
- case TClassEdit::kSet:
+ case ROOT::kSTLvector:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLset:
switch (fVal->fCase) {
case kIsFundamental: // Only handle primitives this way
case kIsEnum:
@@ -1461,8 +1461,8 @@ void TGenCollectionStreamer::Streamer(TBuffer &b)
return;
}
break;
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
WriteMap(nElements, b);
break;
}
@@ -1481,15 +1481,15 @@ void TGenCollectionStreamer::StreamerAsMap(TBuffer &b)
}
if (nElements > 0) {
switch (fSTL_type) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
ReadMap(nElements, b, fOnFileClass);
break;
- case TClassEdit::kVector:
- case TClassEdit::kList:
- case TClassEdit::kDeque:
- case TClassEdit::kMultiSet:
- case TClassEdit::kSet: {
+ case ROOT::kSTLvector:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLset: {
ReadPairFromMap(nElements, b);
break;
}
diff --git a/io/io/src/TMakeProject.cxx b/io/io/src/TMakeProject.cxx
index 952a5da117b..75ed04dfbd3 100644
--- a/io/io/src/TMakeProject.cxx
+++ b/io/io/src/TMakeProject.cxx
@@ -457,28 +457,28 @@ UInt_t TMakeProject::GenerateIncludeForTemplate(FILE *fp, const char *clname, ch
} else if ((stlType = TClassEdit::IsSTLCont(incName))) {
const char *what = "";
switch (TMath::Abs(stlType)) {
- case TClassEdit::kVector:
+ case ROOT::kSTLvector:
what = "vector";
break;
- case TClassEdit::kList:
+ case ROOT::kSTLlist:
what = "list";
break;
- case TClassEdit::kDeque:
+ case ROOT::kSTLdeque:
what = "deque";
break;
- case TClassEdit::kMap:
+ case ROOT::kSTLmap:
what = "map";
break;
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmultimap:
what = "map";
break;
- case TClassEdit::kSet:
+ case ROOT::kSTLset:
what = "set";
break;
- case TClassEdit::kMultiSet:
+ case ROOT::kSTLmultiset:
what = "set";
break;
- case TClassEdit::kBitSet:
+ case ROOT::kSTLbitset:
what = "bitset";
break;
default:
@@ -545,8 +545,8 @@ UInt_t TMakeProject::GenerateIncludeForTemplate(FILE *fp, const char *clname, ch
if (key) {
TString what;
switch (stlkind) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap: {
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap: {
what = "pair<";
what += UpdateAssociativeToVector( inside[1].c_str() );
what += ",";
@@ -592,8 +592,8 @@ void TMakeProject::GeneratePostDeclaration(FILE *fp, const TVirtualStreamerInfo
what = inside[1].c_str();
} else if (key) {
switch (stlkind) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
{
// Already done (see GenerateIncludeForTemplate
break;
@@ -636,17 +636,17 @@ TString TMakeProject::UpdateAssociativeToVector(const char *name)
}
// Remove default allocator if any.
switch (stlkind) {
- case TClassEdit::kVector:
- case TClassEdit::kList:
- case TClassEdit::kDeque:
+ case ROOT::kSTLvector:
+ case ROOT::kSTLlist:
+ case ROOT::kSTLdeque:
if (narg>2 && strncmp(inside[2].c_str(),"std::allocator<",strlen("std::allocator<"))==0) {
--narg;
}
break;
- case TClassEdit::kSet:
- case TClassEdit::kMultiSet:
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
if (narg>4 && strncmp(inside[4].c_str(),"std::allocator<",strlen("std::allocator<"))==0) {
--narg;
}
@@ -660,8 +660,8 @@ TString TMakeProject::UpdateAssociativeToVector(const char *name)
// (for which we do not know the sorting).
std::string what;
switch ( stlkind ) {
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap: {
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap: {
what = "std::pair<";
what += inside[1];
what += ",";
@@ -677,8 +677,8 @@ TString TMakeProject::UpdateAssociativeToVector(const char *name)
narg = 2;
break;
}
- case TClassEdit::kSet:
- case TClassEdit::kMultiSet:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
inside[0] = "std::vector";
break;
}
diff --git a/io/io/src/TStreamerInfo.cxx b/io/io/src/TStreamerInfo.cxx
index 7e8eea1579a..c1314e35526 100644
--- a/io/io/src/TStreamerInfo.cxx
+++ b/io/io/src/TStreamerInfo.cxx
@@ -261,7 +261,7 @@ void TStreamerInfo::Build()
TVirtualCollectionProxy *proxy = base->GetClassPointer()->GetCollectionProxy();
if (proxy) element = new TStreamerSTL(bname, btitle, offset, bname, *proxy, kFALSE);
else element = new TStreamerSTL(bname, btitle, offset, bname, 0, kFALSE);
- if (fClass->IsLoaded() && ((TStreamerSTL*)element)->GetSTLtype() != TClassEdit::kVector) {
+ if (fClass->IsLoaded() && ((TStreamerSTL*)element)->GetSTLtype() != ROOT::kSTLvector) {
if (!element->GetClassPointer()->IsLoaded()) {
Error("Build","The class \"%s\" is compiled and its base class \"%s\" is a collection and we do not have a dictionary for it, we will not be able to read or write this base class.",GetName(),bname);
delete element;
@@ -399,7 +399,7 @@ void TStreamerInfo::Build()
TVirtualCollectionProxy *proxy = TClass::GetClass(dm->GetTypeName() /* the underlying type */)->GetCollectionProxy();
if (proxy) element = new TStreamerSTL(dmName, dmTitle, offset, dmFull, *proxy, dmIsPtr);
else element = new TStreamerSTL(dmName, dmTitle, offset, dmFull, dm->GetTrueTypeName(), dmIsPtr);
- if (fClass->IsLoaded() && ((TStreamerSTL*)element)->GetSTLtype() != TClassEdit::kVector) {
+ if (fClass->IsLoaded() && ((TStreamerSTL*)element)->GetSTLtype() != ROOT::kSTLvector) {
if (!element->GetClassPointer()->IsLoaded()) {
Error("Build","The class \"%s\" is compiled and for its the data member \"%s\", we do not have a dictionary for the collection \"%s\", we will not be able to read or write this data member.",GetName(),dmName,element->GetClassPointer()->GetName());
delete element;
@@ -1488,7 +1488,7 @@ void TStreamerInfo::BuildOld()
continue;
} else if (bc->GetClassPointer()->GetCollectionProxy()
&& !bc->GetClassPointer()->IsLoaded()
- && bc->GetClassPointer()->GetCollectionProxy()->GetCollectionType() != TClassEdit::kVector) {
+ && bc->GetClassPointer()->GetCollectionProxy()->GetCollectionType() != ROOT::kSTLvector) {
Error("BuildOld","The class \"%s\" is compiled and its base class \"%s\" is a collection and we do not have a dictionary for it, we will not be able to read or write this base class.",GetName(),bc->GetName());
offset = kMissing;
element->SetOffset(kMissing);
@@ -1588,7 +1588,7 @@ void TStreamerInfo::BuildOld()
TClass *elemDm = TClass::GetClass(dmClassName.Data());
if (elemDm && elemDm->GetCollectionProxy()
&& !elemDm->IsLoaded()
- && elemDm->GetCollectionProxy()->GetCollectionType() != TClassEdit::kVector) {
+ && elemDm->GetCollectionProxy()->GetCollectionType() != ROOT::kSTLvector) {
Error("BuildOld","The class \"%s\" is compiled and for its data member \"%s\", we do not have a dictionary for the collection \"%s\", we will not be able to read or write this data member.",GetName(),dm->GetName(),elemDm->GetName());
offset = kMissing;
element->SetOffset(kMissing);
@@ -1727,8 +1727,8 @@ void TStreamerInfo::BuildOld()
Int_t oldkind = TMath::Abs(TClassEdit::IsSTLCont( oldClass->GetName() ));
Int_t newkind = TMath::Abs(TClassEdit::IsSTLCont( newClass->GetName() ));
- if ( (oldkind==TClassEdit::kMap || oldkind==TClassEdit::kMultiMap) &&
- (newkind!=TClassEdit::kMap && newkind!=TClassEdit::kMultiMap) ) {
+ if ( (oldkind==ROOT::kSTLmap || oldkind==ROOT::kSTLmultimap) &&
+ (newkind!=ROOT::kSTLmap && newkind!=ROOT::kSTLmultimap) ) {
Int_t elemType = element->GetType();
Bool_t isPrealloc = (elemType == kObjectp) || (elemType == kAnyp) || (elemType == (kObjectp + kOffsetL)) || (elemType == (kAnyp + kOffsetL));
@@ -1754,8 +1754,8 @@ void TStreamerInfo::BuildOld()
}
element->Update(oldClass, newClass.GetClass());
- } else if ( (newkind==TClassEdit::kMap || newkind==TClassEdit::kMultiMap) &&
- (oldkind!=TClassEdit::kMap && oldkind!=TClassEdit::kMultiMap) ) {
+ } else if ( (newkind==ROOT::kSTLmap || newkind==ROOT::kSTLmultimap) &&
+ (oldkind!=ROOT::kSTLmap && oldkind!=ROOT::kSTLmultimap) ) {
element->SetNewType(-2);
} else {
element->Update(oldClass, newClass.GetClass());
@@ -2811,7 +2811,7 @@ static void R__WriteDestructorBody(FILE *file, TIter &next)
//fprintf(file," %s::iterator end (%s %s).end();\n");
//fprintf(file," for( iter = begin; iter != end; ++iter) { delete *iter; }\n");
} else {
- if (stltype == TStreamerElement::kSTLmap || stltype == TStreamerElement::kSTLmultimap) {
+ if (stltype == ROOT::kSTLmap || stltype == ROOT::kSTLmultimap) {
TString enamebasic = TMakeProject::UpdateAssociativeToVector(element->GetTypeNameBasic());
std::vector<std::string> inside;
int nestedLoc;
@@ -2988,10 +2988,10 @@ void TStreamerInfo::GenerateDeclaration(FILE *fp, FILE *sfp, const TList *subCla
// comparator function.
Int_t stltype = ((TStreamerSTL*)element)->GetSTLtype();
switch (stltype) {
- case TStreamerElement::kSTLmap:
- case TStreamerElement::kSTLmultimap:
- case TStreamerElement::kSTLset:
- case TStreamerElement::kSTLmultiset:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
{
enamebasic = TMakeProject::UpdateAssociativeToVector(enamebasic);
}
diff --git a/io/io/src/TStreamerInfoActions.cxx b/io/io/src/TStreamerInfoActions.cxx
index 70388bdf1bd..e2128d80787 100644
--- a/io/io/src/TStreamerInfoActions.cxx
+++ b/io/io/src/TStreamerInfoActions.cxx
@@ -964,11 +964,11 @@ namespace TStreamerInfoActions
ESelectLooper SelectLooper(TVirtualCollectionProxy &proxy)
{
- if ( (proxy.GetCollectionType() == TClassEdit::kVector) || (proxy.GetProperties() & TVirtualCollectionProxy::kIsEmulated) ) {
+ if ( (proxy.GetCollectionType() == ROOT::kSTLvector) || (proxy.GetProperties() & TVirtualCollectionProxy::kIsEmulated) ) {
return kVectorLooper;
- } else if (proxy.GetCollectionType() == TClassEdit::kSet || proxy.GetCollectionType() == TClassEdit::kMultiSet
- || proxy.GetCollectionType() == TClassEdit::kMap || proxy.GetCollectionType() == TClassEdit::kMultiMap
- || proxy.GetCollectionType() == TClassEdit::kBitSet) {
+ } else if (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
+ || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap
+ || proxy.GetCollectionType() == ROOT::kSTLbitset) {
return kAssociativeLooper;
} else {
return kGenericLooper;
@@ -2870,7 +2870,7 @@ TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::Cr
}
UInt_t ndata = info->GetElements()->GetEntries();
TStreamerInfoActions::TActionSequence *sequence = new TStreamerInfoActions::TActionSequence(info,ndata);
- if ( (proxy.GetCollectionType() == TClassEdit::kVector) || (proxy.GetProperties() & TVirtualCollectionProxy::kIsEmulated) )
+ if ( (proxy.GetCollectionType() == ROOT::kSTLvector) || (proxy.GetProperties() & TVirtualCollectionProxy::kIsEmulated) )
{
if (proxy.HasPointers()) {
// Instead of the creating a new one let's copy the one from the StreamerInfo.
@@ -2884,8 +2884,8 @@ TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::Cr
// We can speed up the iteration in case of vector. We also know that all emulated collection are stored internally as a vector.
Long_t increment = proxy.GetIncrement();
sequence->fLoopConfig = new TVectorLoopConfig(increment);
- } else if (proxy.GetCollectionType() == TClassEdit::kSet || proxy.GetCollectionType() == TClassEdit::kMultiSet
- || proxy.GetCollectionType() == TClassEdit::kMap || proxy.GetCollectionType() == TClassEdit::kMultiMap)
+ } else if (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
+ || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap)
{
Long_t increment = proxy.GetIncrement();
sequence->fLoopConfig = new TVectorLoopConfig(increment);
@@ -2929,8 +2929,8 @@ TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::Cr
}
switch (SelectLooper(proxy)) {
case kAssociativeLooper:
-// } else if (proxy.GetCollectionType() == TClassEdit::kSet || proxy.GetCollectionType() == TClassEdit::kMultiSet
-// || proxy.GetCollectionType() == TClassEdit::kMap || proxy.GetCollectionType() == TClassEdit::kMultiMap) {
+// } else if (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
+// || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap) {
// sequence->AddAction( GenericAssocCollectionAction, new TConfigSTL(info,i,offset,0,proxy.GetCollectionClass(),0,0) );
case kVectorLooper:
case kVectorPtrLooper:
@@ -2973,7 +2973,7 @@ TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::Cr
}
UInt_t ndata = info->GetElements()->GetEntries();
TStreamerInfoActions::TActionSequence *sequence = new TStreamerInfoActions::TActionSequence(info,ndata);
- if ( (proxy.GetCollectionType() == TClassEdit::kVector) || (proxy.GetProperties() & TVirtualCollectionProxy::kIsEmulated) )
+ if ( (proxy.GetCollectionType() == ROOT::kSTLvector) || (proxy.GetProperties() & TVirtualCollectionProxy::kIsEmulated) )
{
if (proxy.HasPointers()) {
// Instead of the creating a new one let's copy the one from the StreamerInfo.
@@ -2987,8 +2987,8 @@ TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::Cr
// We can speed up the iteration in case of vector. We also know that all emulated collection are stored internally as a vector.
Long_t increment = proxy.GetIncrement();
sequence->fLoopConfig = new TVectorLoopConfig(increment);
- /*} else if (proxy.GetCollectionType() == TClassEdit::kSet || proxy.GetCollectionType() == TClassEdit::kMultiSet
- || proxy.GetCollectionType() == TClassEdit::kMap || proxy.GetCollectionType() == TClassEdit::kMultiMap)
+ /*} else if (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
+ || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap)
{
Long_t increment = proxy.GetIncrement();
sequence->fLoopConfig = new TVectorLoopConfig(increment);
@@ -3035,9 +3035,9 @@ TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::Cr
oldType += TVirtualStreamerInfo::kSkip;
}
}
- if ( (proxy.GetCollectionType() == TClassEdit::kVector) || (proxy.GetProperties() & TVirtualCollectionProxy::kIsEmulated)
- /*|| (proxy.GetCollectionType() == TClassEdit::kSet || proxy.GetCollectionType() == TClassEdit::kMultiSet
- || proxy.GetCollectionType() == TClassEdit::kMap || proxy.GetCollectionType() == TClassEdit::kMultiMap) */ )
+ if ( (proxy.GetCollectionType() == ROOT::kSTLvector) || (proxy.GetProperties() & TVirtualCollectionProxy::kIsEmulated)
+ /*|| (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
+ || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap) */ )
{
// We can speed up the iteration in case of vector. We also know that all emulated collection are stored internally as a vector.
@@ -3048,8 +3048,8 @@ TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::Cr
sequence->AddAction(GetCollectionWriteAction<VectorLooper>(info,element,oldType,i,offset));
}
- // } else if (proxy.GetCollectionType() == TClassEdit::kSet || proxy.GetCollectionType() == TClassEdit::kMultiSet
- // || proxy.GetCollectionType() == TClassEdit::kMap || proxy.GetCollectionType() == TClassEdit::kMultiMap) {
+ // } else if (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
+ // || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap) {
// sequence->AddAction( GenericAssocCollectionAction, new TConfigSTL(info,i,offset,0,proxy.GetCollectionClass(),0,0) );
} else {
// The usual collection case.
@@ -3108,9 +3108,9 @@ TStreamerInfoActions::TActionSequence *TStreamerInfoActions::TActionSequence::Cr
}
}
#else
- if ( (proxy.GetCollectionType() == TClassEdit::kVector) || (proxy.GetProperties() & TVirtualCollectionProxy::kIsEmulated)
- /*|| (proxy.GetCollectionType() == TClassEdit::kSet || proxy.GetCollectionType() == TClassEdit::kMultiSet
- || proxy.GetCollectionType() == TClassEdit::kMap || proxy.GetCollectionType() == TClassEdit::kMultiMap)*/ )
+ if ( (proxy.GetCollectionType() == ROOT::kSTLvector) || (proxy.GetProperties() & TVirtualCollectionProxy::kIsEmulated)
+ /*|| (proxy.GetCollectionType() == ROOT::kSTLset || proxy.GetCollectionType() == ROOT::kSTLmultiset
+ || proxy.GetCollectionType() == ROOT::kSTLmap || proxy.GetCollectionType() == ROOT::kSTLmultimap)*/ )
{
sequence->AddAction( GetCollectionWriteAction<VectorLooper>(info,element,oldType,i,offset) );
} else {
diff --git a/io/xml/src/TXMLPlayer.cxx b/io/xml/src/TXMLPlayer.cxx
index 9912132e981..5ce5a2e55bf 100644
--- a/io/xml/src/TXMLPlayer.cxx
+++ b/io/xml/src/TXMLPlayer.cxx
@@ -947,7 +947,7 @@ Bool_t TXMLPlayer::ProduceSTLstreamer(std::ostream& fs, TClass* cl, TStreamerSTL
TClass* contcl = el->GetClassPointer();
- Bool_t isstr = (el->GetSTLtype() == TStreamerElement::kSTLstring);
+ Bool_t isstr = (el->GetSTLtype() == ROOT::kSTLstring);
Bool_t isptr = el->IsaPointer();
Bool_t isarr = (el->GetArrayLength()>0);
Bool_t isparent = (strcmp(el->GetName(), contcl->GetName())==0);
@@ -968,13 +968,13 @@ Bool_t TXMLPlayer::ProduceSTLstreamer(std::ostream& fs, TClass* cl, TStreamerSTL
stltyp = TClassEdit::STLKind(splitName[0].c_str());
switch (stltyp) {
- case TClassEdit::kVector : narg = 1; break;
- case TClassEdit::kList : narg = 1; break;
- case TClassEdit::kDeque : narg = 1; break;
- case TClassEdit::kMap : narg = 2; break;
- case TClassEdit::kMultiMap : narg = 2; break;
- case TClassEdit::kSet : narg = 1; break;
- case TClassEdit::kMultiSet : narg = 1; break;
+ case ROOT::kSTLvector : narg = 1; break;
+ case ROOT::kSTLlist : narg = 1; break;
+ case ROOT::kSTLdeque : narg = 1; break;
+ case ROOT::kSTLmap : narg = 2; break;
+ case ROOT::kSTLmultimap : narg = 2; break;
+ case ROOT::kSTLset : narg = 1; break;
+ case ROOT::kSTLmultiset : narg = 1; break;
default: return false;
}
@@ -1163,7 +1163,7 @@ Bool_t TXMLPlayer::ProduceSTLstreamer(std::ostream& fs, TClass* cl, TStreamerSTL
if (akaarrayaccess) {
fs << std::endl << tabs << tab1 << accname;
- if ((stltyp==TClassEdit::kSet) || (stltyp==TClassEdit::kMultiSet))
+ if ((stltyp==ROOT::kSTLset) || (stltyp==ROOT::kSTLmultiset))
fs << "insert"; else fs << "push_back";
fs << "(arr[k]);" << std::endl;
fs << tabs << "delete[] arr;" << std::endl;
@@ -1175,7 +1175,7 @@ Bool_t TXMLPlayer::ProduceSTLstreamer(std::ostream& fs, TClass* cl, TStreamerSTL
fs << tabs << tab1;
if (ifcond.Length()>0) fs << "if (" << ifcond << ") ";
fs << accname;
- if ((stltyp==TClassEdit::kSet) || (stltyp==TClassEdit::kMultiSet))
+ if ((stltyp==ROOT::kSTLset) || (stltyp==ROOT::kSTLmultiset))
fs << "insert";
else
fs << "push_back";
diff --git a/tree/tree/src/TBranchElement.cxx b/tree/tree/src/TBranchElement.cxx
index f8af76e680f..e07000b9009 100644
--- a/tree/tree/src/TBranchElement.cxx
+++ b/tree/tree/src/TBranchElement.cxx
@@ -149,7 +149,7 @@ TBranchElement::TBranchElement()
, fType(0)
, fStreamerType(-1)
, fMaximum(0)
-, fSTLtype(TClassEdit::kNotSTL)
+, fSTLtype(ROOT::kNotSTL)
, fNdata(1)
, fBranchCount(0)
, fBranchCount2(0)
@@ -189,7 +189,7 @@ TBranchElement::TBranchElement(TTree *tree, const char* bname, TStreamerInfo* si
, fType(0)
, fStreamerType(-1)
, fMaximum(0)
-, fSTLtype(TClassEdit::kNotSTL)
+, fSTLtype(ROOT::kNotSTL)
, fNdata(1)
, fBranchCount(0)
, fBranchCount2(0)
@@ -230,7 +230,7 @@ TBranchElement::TBranchElement(TBranch *parent, const char* bname, TStreamerInfo
, fType(0)
, fStreamerType(-1)
, fMaximum(0)
-, fSTLtype(TClassEdit::kNotSTL)
+, fSTLtype(ROOT::kNotSTL)
, fNdata(1)
, fBranchCount(0)
, fBranchCount2(0)
@@ -548,7 +548,7 @@ void TBranchElement::Init(TTree *tree, TBranch *parent,const char* bname, TStrea
SetReadLeavesPtr();
SetFillLeavesPtr();
return;
- } else if (((fSTLtype >= TClassEdit::kVector) && (fSTLtype < TClassEdit::kEnd)) || ((fSTLtype > -TClassEdit::kEnd) && (fSTLtype <= -TClassEdit::kVector))) {
+ } else if (((fSTLtype >= ROOT::kSTLvector) && (fSTLtype < ROOT::kSTLend)) || ((fSTLtype > -ROOT::kSTLend) && (fSTLtype <= -ROOT::kSTLvector))) {
// -- We are an STL container element.
TClass* contCl = TClass::GetClass(elem_type);
fCollProxy = contCl->GetCollectionProxy()->Generate();
@@ -711,7 +711,7 @@ void TBranchElement::Init(TTree *tree, TBranch *parent, const char* bname, TClon
fOnfileObject = 0;
fMaximum = 0;
fBranchOffset = 0;
- fSTLtype = TClassEdit::kNotSTL;
+ fSTLtype = ROOT::kNotSTL;
fInitOffsets = kFALSE;
fTree = tree;
@@ -1408,7 +1408,7 @@ void TBranchElement::FillLeavesCollection(TBuffer& b)
}
b << n;
- if(fSTLtype != TClassEdit::kVector && proxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
+ if(fSTLtype != ROOT::kSTLvector && proxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
fPtrIterators->CreateIterators(fObject, proxy);
} else {
//NOTE: this does not work for not vectors since the CreateIterators expects a TGenCollectionProxy::TStaging as its argument!
@@ -2253,10 +2253,10 @@ Int_t TBranchElement::GetEntry(Long64_t entry, Int_t getall)
nbytes += nb;
}
switch(fSTLtype) {
- case TClassEdit::kSet:
- case TClassEdit::kMultiSet:
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
break;
default:
ValidateAddress(); // There is no ReadLeave for this node, so we need to do the validation here.
@@ -3452,10 +3452,10 @@ void TBranchElement::ReadLeavesMakeClass(TBuffer& b)
if (fType == 4) {
Int_t nbranches = fBranches.GetEntriesFast();
switch(fSTLtype) {
- case TClassEdit::kSet:
- case TClassEdit::kMultiSet:
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
for (Int_t i=0; i<nbranches; i++) {
TBranch *branch = (TBranch*)fBranches[i];
Int_t nb = branch->GetEntry(GetReadEntry(), 1);
@@ -3711,7 +3711,7 @@ void TBranchElement::ReadLeavesCollection(TBuffer& b)
TVirtualCollectionProxy* proxy = GetCollectionProxy();
TVirtualCollectionProxy::TPushPop helper(proxy, fObject);
void* alternate = proxy->Allocate(fNdata, true);
- if(fSTLtype != TClassEdit::kVector && proxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
+ if(fSTLtype != ROOT::kSTLvector && proxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
fPtrIterators->CreateIterators(alternate, proxy);
} else {
fIterators->CreateIterators(alternate, proxy);
@@ -3719,10 +3719,10 @@ void TBranchElement::ReadLeavesCollection(TBuffer& b)
Int_t nbranches = fBranches.GetEntriesFast();
switch (fSTLtype) {
- case TClassEdit::kSet:
- case TClassEdit::kMultiSet:
- case TClassEdit::kMap:
- case TClassEdit::kMultiMap:
+ case ROOT::kSTLset:
+ case ROOT::kSTLmultiset:
+ case ROOT::kSTLmap:
+ case ROOT::kSTLmultimap:
for (Int_t i = 0; i < nbranches; ++i) {
TBranch *branch = (TBranch*) fBranches[i];
Int_t nb = branch->GetEntry(GetReadEntry(), 1);
@@ -4480,7 +4480,7 @@ void TBranchElement::SetAddress(void* addr)
SetReadLeavesPtr();
SetFillLeavesPtr();
- if(fSTLtype != TClassEdit::kVector && fCollProxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
+ if(fSTLtype != ROOT::kSTLvector && fCollProxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
fPtrIterators = new TVirtualCollectionPtrIterators(fCollProxy);
} else {
fIterators = new TVirtualCollectionIterators(fCollProxy);
@@ -4518,7 +4518,7 @@ void TBranchElement::SetAddress(void* addr)
SetFillLeavesPtr();
delete fIterators;
delete fPtrIterators;
- if(fSTLtype != TClassEdit::kVector && fCollProxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
+ if(fSTLtype != ROOT::kSTLvector && fCollProxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
fPtrIterators = new TVirtualCollectionPtrIterators(fCollProxy);
} else {
fIterators = new TVirtualCollectionIterators(fCollProxy);
@@ -4551,7 +4551,7 @@ void TBranchElement::SetAddress(void* addr)
SetFillLeavesPtr();
delete fIterators;
delete fPtrIterators;
- if(fSTLtype != TClassEdit::kVector && fCollProxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
+ if(fSTLtype != ROOT::kSTLvector && fCollProxy->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
fPtrIterators = new TVirtualCollectionPtrIterators(fCollProxy);
} else {
fIterators = new TVirtualCollectionIterators(fCollProxy);
@@ -4616,7 +4616,7 @@ void TBranchElement::SetAddress(void* addr)
}
} else {
if (!fIterators && !fPtrIterators) {
- if(fSTLtype != TClassEdit::kVector && GetCollectionProxy()->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
+ if(fSTLtype != ROOT::kSTLvector && GetCollectionProxy()->HasPointers() && fSplitLevel > TTree::kSplitCollectionOfPointers ) {
fPtrIterators = new TVirtualCollectionPtrIterators(GetCollectionProxy());
} else {
fIterators = new TVirtualCollectionIterators(GetCollectionProxy());
@@ -4967,7 +4967,7 @@ void TBranchElement::SetReadActionSequence()
TStreamerInfoActions::TActionSequence *original = 0;
TStreamerInfoActions::TActionSequence *transient = 0;
if (fType == 41) {
- if( fSplitLevel >= TTree::kSplitCollectionOfPointers && fBranchCount->fSTLtype == TClassEdit::kVector) {
+ if( fSplitLevel >= TTree::kSplitCollectionOfPointers && fBranchCount->fSTLtype == ROOT::kSTLvector) {
original = fInfo->GetReadMemberWiseActions(kTRUE);
} else {
TVirtualStreamerInfo *info = GetInfoImp();
@@ -5010,7 +5010,7 @@ void TBranchElement::SetReadLeavesPtr()
fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesCollection;
} else if (fType == 41) {
if( fSplitLevel >= TTree::kSplitCollectionOfPointers ) {
- if (fBranchCount->fSTLtype == TClassEdit::kVector) {
+ if (fBranchCount->fSTLtype == ROOT::kSTLvector) {
fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesCollectionSplitVectorPtrMember;
} else {
fReadLeaves = (ReadLeaves_t)&TBranchElement::ReadLeavesCollectionSplitPtrMember;
@@ -5054,7 +5054,7 @@ void TBranchElement::SetFillActionSequence()
TStreamerInfoActions::TActionSequence *original = 0;
TStreamerInfoActions::TActionSequence *transient = 0;
if (fType == 41) {
- if( fSplitLevel >= TTree::kSplitCollectionOfPointers && fBranchCount->fSTLtype == TClassEdit::kVector) {
+ if( fSplitLevel >= TTree::kSplitCollectionOfPointers && fBranchCount->fSTLtype == ROOT::kSTLvector) {
original = fInfo->GetWriteMemberWiseActions(kTRUE);
} else {
TVirtualStreamerInfo *info = GetInfoImp();
@@ -5098,7 +5098,7 @@ void TBranchElement::SetFillLeavesPtr()
fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesCollection;
} else if (fType == 41) {
if( fSplitLevel >= TTree::kSplitCollectionOfPointers ) {
- if (fBranchCount->fSTLtype == TClassEdit::kVector) {
+ if (fBranchCount->fSTLtype == ROOT::kSTLvector) {
fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesCollectionSplitVectorPtrMember;
} else {
fFillLeaves = (FillLeaves_t)&TBranchElement::FillLeavesCollectionSplitPtrMember;
diff --git a/tree/tree/src/TTree.cxx b/tree/tree/src/TTree.cxx
index 0f3757d0b1e..5bd447b01ed 100644
--- a/tree/tree/src/TTree.cxx
+++ b/tree/tree/src/TTree.cxx
@@ -2122,7 +2122,7 @@ TBranch* TTree::BronchExec(const char* name, const char* classname, void* addr,
}
if ((splitlevel > 0) && inklass && (inklass->GetCollectionProxy() == 0)) {
Int_t stl = -TClassEdit::IsSTLCont(cl->GetName(), 0);
- if ((stl != TClassEdit::kMap) && (stl != TClassEdit::kMultiMap)) {
+ if ((stl != ROOT::kSTLmap) && (stl != ROOT::kSTLmultimap)) {
void *classinfo = inklass->GetClassInfo();
if (!classinfo) {
Error("Bronch", "Container with no dictionary defined in branch: %s", name);
diff --git a/tree/treeplayer/src/TTreeProxyGenerator.cxx b/tree/treeplayer/src/TTreeProxyGenerator.cxx
index fe5ccfcae54..9118e9a459d 100644
--- a/tree/treeplayer/src/TTreeProxyGenerator.cxx
+++ b/tree/treeplayer/src/TTreeProxyGenerator.cxx
@@ -385,18 +385,18 @@ namespace ROOT {
} else if (cl->GetCollectionProxy() && (stlType=TClassEdit::IsSTLCont(cl->GetName()))) {
const char *what = "";
switch(stlType) {
- case TClassEdit::kVector: what = "vector"; break;
- case TClassEdit::kList: what = "list"; break;
- case -TClassEdit::kDeque: // same as positive
- case TClassEdit::kDeque: what = "deque"; break;
- case -TClassEdit::kMap: // same as positive
- case TClassEdit::kMap: what = "map"; break;
- case -TClassEdit::kMultiMap: // same as positive
- case TClassEdit::kMultiMap: what = "map"; break;
- case -TClassEdit::kSet: // same as positive
- case TClassEdit::kSet: what = "set"; break;
- case -TClassEdit::kMultiSet: // same as positive
- case TClassEdit::kMultiSet: what = "set"; break;
+ case ROOT::kSTLvector: what = "vector"; break;
+ case ROOT::kSTLlist: what = "list"; break;
+ case -ROOT::kSTLdeque: // same as positive
+ case ROOT::kSTLdeque: what = "deque"; break;
+ case -ROOT::kSTLmap: // same as positive
+ case ROOT::kSTLmap: what = "map"; break;
+ case -ROOT::kSTLmultimap: // same as positive
+ case ROOT::kSTLmultimap: what = "map"; break;
+ case -ROOT::kSTLset: // same as positive
+ case ROOT::kSTLset: what = "set"; break;
+ case -ROOT::kSTLmultiset: // same as positive
+ case ROOT::kSTLmultiset: what = "set"; break;
}
if (what[0]) {
directive = "#include <";
diff --git a/tree/treeplayer/src/TTreeReaderArray.cxx b/tree/treeplayer/src/TTreeReaderArray.cxx
index e214f9721fb..d108c367ff8 100644
--- a/tree/treeplayer/src/TTreeReaderArray.cxx
+++ b/tree/treeplayer/src/TTreeReaderArray.cxx
@@ -611,8 +611,8 @@ const char* ROOT::TTreeReaderArrayBase::GetBranchContentDataType(TBranch* branch
Error("GetBranchContentDataType()", "Cannot determine STL collection type of %s stored in branch %s", brElement->GetClassName(), branch->GetName());
return brElement->GetClassName();
}
- bool isMap = isSTLCont == TClassEdit::kMap
- || isSTLCont == TClassEdit::kMultiMap;
+ bool isMap = isSTLCont == ROOT::kSTLmap
+ || isSTLCont == ROOT::kSTLmultimap;
if (isMap) contentTypeName = "std::pair< ";
contentTypeName += splitType.fElements[1];
if (isMap) {
--
GitLab