|
| clang::QualType | ROOT::TMetaUtils::AddDefaultParameters (clang::QualType instanceType, const cling::Interpreter &interpret, const TNormalizedCtxt &normCtxt) |
| | Add any unspecified template parameters to the class template instance, mentioned anywhere in the type.
|
| |
| bool | ROOT::TMetaUtils::BeginsWith (const std::string &theString, const std::string &theSubstring) |
| |
| EIOCtorCategory | ROOT::TMetaUtils::CheckConstructor (const clang::CXXRecordDecl *, const RConstructorType &, const cling::Interpreter &interp) |
| | Check if class has constructor of provided type - either default or with single argument.
|
| |
| bool | ROOT::TMetaUtils::CheckDefaultConstructor (const clang::CXXRecordDecl *, const cling::Interpreter &interp) |
| | Checks if default constructor exists and accessible.
|
| |
| EIOCtorCategory | ROOT::TMetaUtils::CheckIOConstructor (const clang::CXXRecordDecl *, const char *, const clang::CXXRecordDecl *, const cling::Interpreter &interp) |
| | Checks IO constructor - must be public and with specified argument.
|
| |
| bool | ROOT::TMetaUtils::CheckPublicFuncWithProto (clang::CXXRecordDecl const *, char const *, char const *, const cling::Interpreter &, bool diagnose) |
| | Return true, if the function (defined by the name and prototype) exists and is public.
|
| |
| const clang::FunctionDecl * | ROOT::TMetaUtils::ClassInfo__HasMethod (const clang::DeclContext *cl, char const *, const cling::Interpreter &interp) |
| |
| static const std::string | ROOT::TMetaUtils::propNames::comment ("comment") |
| |
| llvm::StringRef | ROOT::TMetaUtils::DataMemberInfo__ValidArrayIndex (const cling::Interpreter &interp, const clang::DeclaratorDecl &m, int *errnum=nullptr, llvm::StringRef *errstr=nullptr) |
| | ValidArrayIndex return a static string (so use it or copy it immediatly, do not call GrabIndex twice in the same expression) containing the size of the array data member.
|
| |
| const std::string | ROOT::TMetaUtils::AST2SourceTools::Decls2FwdDecls (const std::vector< const clang::Decl * > &decls, bool(*ignoreFiles)(const clang::PresumedLoc &), const cling::Interpreter &interp, std::string *logs) |
| |
| static std::string | ROOT::TMetaUtils::DemangleNameForDlsym (const std::string &name) |
| |
| int | ROOT::TMetaUtils::ElementStreamer (std::ostream &finalString, const clang::NamedDecl &forcontext, const clang::QualType &qti, const char *t, int rwmode, const cling::Interpreter &interp, const char *tcl=0) |
| |
| int | ROOT::TMetaUtils::AST2SourceTools::EncloseInNamespaces (const clang::Decl &decl, std::string &defString) |
| | Take the namespaces which enclose the decl and put them around the definition string.
|
| |
| const clang::RecordDecl * | ROOT::TMetaUtils::AST2SourceTools::EncloseInScopes (const clang::Decl &decl, std::string &defString) |
| | Take the scopes which enclose the decl and put them around the definition string.
|
| |
| bool | ROOT::TMetaUtils::EndsWith (const std::string &theString, const std::string &theSubstring) |
| |
| void | ROOT::TMetaUtils::Error (const char *location, const char *fmt,...) |
| |
| bool | ROOT::TMetaUtils::ExtractAttrIntPropertyFromName (const clang::Decl &decl, const std::string &propName, int &propValue) |
| | This routine counts on the "propName<separator>propValue" format.
|
| |
| bool | ROOT::TMetaUtils::ExtractAttrPropertyFromName (const clang::Decl &decl, const std::string &propName, std::string &propValue) |
| | This routine counts on the "propName<separator>propValue" format.
|
| |
| int | ROOT::TMetaUtils::extractAttrString (clang::Attr *attribute, std::string &attrString) |
| | Extract attr string.
|
| |
| void | ROOT::TMetaUtils::ExtractCtxtEnclosingNameSpaces (const clang::DeclContext &, std::list< std::pair< std::string, bool > > &) |
| | Extract enclosing namespaces recursively.
|
| |
| void | ROOT::TMetaUtils::ExtractEnclosingNameSpaces (const clang::Decl &, std::list< std::pair< std::string, bool > > &) |
| | Extract the immediately outer namespace and then launch the recursion.
|
| |
| const clang::RecordDecl * | ROOT::TMetaUtils::ExtractEnclosingScopes (const clang::Decl &decl, std::list< std::pair< std::string, unsigned int > > &enclosingSc) |
| | Extract the names and types of containing scopes.
|
| |
| int | ROOT::TMetaUtils::extractPropertyNameVal (clang::Attr *attribute, std::string &attrName, std::string &attrValue) |
| |
| int | ROOT::TMetaUtils::extractPropertyNameValFromString (const std::string attributeStr, std::string &attrName, std::string &attrValue) |
| |
| clang::TemplateName | ROOT::TMetaUtils::ExtractTemplateNameFromQualType (const clang::QualType &qt) |
| | These manipulations are necessary because a template specialisation type does not inherit from a record type (there is an asymmetry between the decls and the types in the clang interface).
|
| |
| void | ROOT::TMetaUtils::Fatal (const char *location, const char *fmt,...) |
| |
| void | ROOT::TMetaUtils::foreachHeaderInModule (const clang::Module &module, const std::function< void(const clang::Module::Header &)> &closure, bool includeDirectlyUsedModules=true) |
| | Calls the given lambda on every header in the given module.
|
| |
| int | ROOT::TMetaUtils::AST2SourceTools::FwdDeclFromFcnDecl (const clang::FunctionDecl &fcnDecl, const cling::Interpreter &interpreter, std::string &defString) |
| |
| int | ROOT::TMetaUtils::AST2SourceTools::FwdDeclFromRcdDecl (const clang::RecordDecl &recordDecl, const cling::Interpreter &interpreter, std::string &defString, bool acceptStl=false) |
| | Convert a rcd decl to its fwd decl If this is a template specialisation, treat in the proper way.
|
| |
| int | ROOT::TMetaUtils::AST2SourceTools::FwdDeclFromTmplDecl (const clang::TemplateDecl &tmplDecl, const cling::Interpreter &interpreter, std::string &defString) |
| | Convert a tmplt decl to its fwd decl.
|
| |
| int | ROOT::TMetaUtils::AST2SourceTools::FwdDeclFromTypeDefNameDecl (const clang::TypedefNameDecl &tdnDecl, const cling::Interpreter &interpreter, std::string &fwdDeclString, std::unordered_set< std::string > *fwdDeclSet=nullptr) |
| | Extract "forward declaration" of a typedef.
|
| |
| int | ROOT::TMetaUtils::AST2SourceTools::FwdDeclIfTmplSpec (const clang::RecordDecl &recordDecl, const cling::Interpreter &interpreter, std::string &defString, const std::string &normalizedName) |
| | Convert a tmplt decl to its fwd decl.
|
| |
| const clang::TagDecl * | ROOT::TMetaUtils::GetAnnotatedRedeclarable (const clang::TagDecl *TND) |
| |
| const clang::TypedefNameDecl * | ROOT::TMetaUtils::GetAnnotatedRedeclarable (const clang::TypedefNameDecl *TND) |
| |
| template<typename T > |
| const T * | ROOT::TMetaUtils::GetAnnotatedRedeclarable (const T *Redecl) |
| |
| llvm::StringRef | ROOT::TMetaUtils::GetClassComment (const clang::CXXRecordDecl &decl, clang::SourceLocation *loc, const cling::Interpreter &interpreter) |
| | Return the class comment after the ClassDef: class MyClass { ... ClassDef(MyClass, 1) // class comment.
|
| |
| int | ROOT::TMetaUtils::GetClassVersion (const clang::RecordDecl *cl, const cling::Interpreter &interp) |
| | Return the version number of the class or -1 if the function Class_Version does not exist.
|
| |
| llvm::StringRef | ROOT::TMetaUtils::GetComment (const clang::Decl &decl, clang::SourceLocation *loc=0) |
| | Returns the comment (// striped away), annotating declaration in a meaningful for ROOT IO way.
|
| |
| void | ROOT::TMetaUtils::GetCppName (std::string &output, const char *input) |
| | Return (in the argument 'output') a mangled version of the C++ symbol/type (pass as 'input') that can be used in C++ as a variable name.
|
| |
| int | ROOT::TMetaUtils::AST2SourceTools::GetDefArg (const clang::ParmVarDecl &par, std::string &valAsString, const clang::PrintingPolicy &pp) |
| | Get the default value as string.
|
| |
| int & | ROOT::TMetaUtils::GetErrorIgnoreLevel () |
| |
| std::string | ROOT::TMetaUtils::GetFileName (const clang::Decl &decl, const cling::Interpreter &interp) |
| | Return the header file to be included to declare the Decl.
|
| |
| void | ROOT::TMetaUtils::GetFullyQualifiedTypeName (std::string &name, const clang::QualType &type, const clang::ASTContext &) |
| |
| void | ROOT::TMetaUtils::GetFullyQualifiedTypeName (std::string &name, const clang::QualType &type, const cling::Interpreter &interpreter) |
| |
| const clang::FunctionDecl * | ROOT::TMetaUtils::GetFuncWithProto (const clang::Decl *cinfo, const char *method, const char *proto, const cling::Interpreter &gInterp, bool diagnose) |
| |
| long | ROOT::TMetaUtils::GetLineNumber (clang::Decl const *) |
| | It looks like the template specialization decl actually contains less information on the location of the code than the decl (in case where there is forward declaration, that is what the specialization points to.
|
| |
| std::string | ROOT::TMetaUtils::GetModuleFileName (const char *moduleName) |
| | Return the dictionary file name for a module.
|
| |
| std::pair< std::string, clang::QualType > | ROOT::TMetaUtils::GetNameTypeForIO (const clang::QualType &templateInstanceType, const cling::Interpreter &interpreter, const TNormalizedCtxt &normCtxt, TClassEdit::EModType mode=TClassEdit::kNone) |
| |
| bool | ROOT::TMetaUtils::GetNameWithinNamespace (std::string &, std::string &, std::string &, clang::CXXRecordDecl const *) |
| | Return true if one of the class' enclosing scope is a namespace and set fullname to the fully qualified name, clsname to the name within a namespace and nsname to the namespace fully qualified name.
|
| |
| void | ROOT::TMetaUtils::GetNormalizedName (std::string &norm_name, const clang::QualType &type, const cling::Interpreter &interpreter, const TNormalizedCtxt &normCtxt) |
| | Return the type name normalized for ROOT, keeping only the ROOT opaque typedef (Double32_t, etc.) and adding default template argument for all types except the STL collections where we remove the default template argument if any.
|
| |
| void | ROOT::TMetaUtils::GetNormalizedName (std::string &norm_name, const clang::TypeDecl *typeDecl, const cling::Interpreter &interpreter) |
| |
| clang::QualType | ROOT::TMetaUtils::GetNormalizedType (const clang::QualType &type, const cling::Interpreter &interpreter, const TNormalizedCtxt &normCtxt) |
| | Return the type normalized for ROOT, keeping only the ROOT opaque typedef (Double32_t, etc.) and adding default template argument for all types except those explicitly requested to be drop by the user.
|
| |
| unsigned int & | ROOT::TMetaUtils::GetNumberOfErrors () |
| |
| const std::string & | ROOT::TMetaUtils::GetPathSeparator () |
| | Return the separator suitable for this platform.
|
| |
| std::string | ROOT::TMetaUtils::GetQualifiedName (const AnnotatedRecordDecl &annotated) |
| |
| std::string | ROOT::TMetaUtils::GetQualifiedName (const clang::NamedDecl &nd) |
| |
| std::string | ROOT::TMetaUtils::GetQualifiedName (const clang::QualType &type, const clang::NamedDecl &forcontext) |
| |
| std::string | ROOT::TMetaUtils::GetQualifiedName (const clang::RecordDecl &recordDecl) |
| |
| std::string | ROOT::TMetaUtils::GetQualifiedName (const clang::Type &type, const clang::NamedDecl &forcontext) |
| |
| void | ROOT::TMetaUtils::GetQualifiedName (std::string &qual_name, const AnnotatedRecordDecl &annotated) |
| |
| void | ROOT::TMetaUtils::GetQualifiedName (std::string &qual_name, const clang::NamedDecl &nd) |
| | This implementation does not rely on GetFullyQualifiedTypeName.
|
| |
| void | ROOT::TMetaUtils::GetQualifiedName (std::string &qual_name, const clang::QualType &type, const clang::NamedDecl &forcontext) |
| | Main implementation relying on GetFullyQualifiedTypeName All other GetQualifiedName functions leverage this one except the one for namespaces.
|
| |
| void | ROOT::TMetaUtils::GetQualifiedName (std::string &qual_name, const clang::RecordDecl &recordDecl) |
| |
| void | ROOT::TMetaUtils::GetQualifiedName (std::string &qual_name, const clang::Type &type, const clang::NamedDecl &forcontext) |
| |
| std::string | ROOT::TMetaUtils::GetRealPath (const std::string &path) |
| |
| std::pair< bool, int > | ROOT::TMetaUtils::GetTrivialIntegralReturnValue (const clang::FunctionDecl *funcCV, const cling::Interpreter &interp) |
| | If the function contains 'just': return SomeValue; this routine will extract this value and return it.
|
| |
| clang::QualType | ROOT::TMetaUtils::GetTypeForIO (const clang::QualType &templateInstanceType, const cling::Interpreter &interpreter, const TNormalizedCtxt &normCtxt, TClassEdit::EModType mode=TClassEdit::kNone) |
| |
| clang::RecordDecl * | ROOT::TMetaUtils::GetUnderlyingRecordDecl (clang::QualType type) |
| |
| const clang::Type * | ROOT::TMetaUtils::GetUnderlyingType (clang::QualType type) |
| | Return the base/underlying type of a chain of array or pointers type.
|
| |
| bool & | ROOT::TMetaUtils::GetWarningsAreErrors () |
| |
| bool | ROOT::TMetaUtils::HasClassDefMacro (const clang::Decl *decl, const cling::Interpreter &interpreter) |
| | Return true if class has any of class declarations like ClassDef, ClassDefNV, ClassDefOverride.
|
| |
| bool | ROOT::TMetaUtils::HasCustomConvStreamerMemberFunction (const AnnotatedRecordDecl &cl, const clang::CXXRecordDecl *clxx, const cling::Interpreter &interp, const TNormalizedCtxt &normCtxt) |
| | Return true if the class has a custom member function streamer.
|
| |
| bool | ROOT::TMetaUtils::HasCustomOperatorNewArrayPlacement (clang::RecordDecl const &, const cling::Interpreter &interp) |
| | return true if we can find a custom operator new with placement
|
| |
| bool | ROOT::TMetaUtils::HasCustomOperatorNewPlacement (char const *, clang::RecordDecl const &, const cling::Interpreter &) |
| | return true if we can find a custom operator new with placement
|
| |
| bool | ROOT::TMetaUtils::HasCustomOperatorNewPlacement (clang::RecordDecl const &, const cling::Interpreter &) |
| | return true if we can find a custom operator new with placement
|
| |
| bool | ROOT::TMetaUtils::HasCustomStreamerMemberFunction (const AnnotatedRecordDecl &cl, const clang::CXXRecordDecl *clxx, const cling::Interpreter &interp, const TNormalizedCtxt &normCtxt) |
| | Return true if the class has a custom member function streamer.
|
| |
| bool | ROOT::TMetaUtils::HasDirectoryAutoAdd (clang::CXXRecordDecl const *, const cling::Interpreter &) |
| | Return true if the class has a method DirectoryAutoAdd(TDirectory *)
|
| |
| bool | ROOT::TMetaUtils::HasIOConstructor (clang::CXXRecordDecl const *, std::string &, const RConstructorTypes &, const cling::Interpreter &) |
| | return true if we can find an constructor calleable without any arguments or with one the IOCtor special types.
|
| |
| bool | ROOT::TMetaUtils::HasNewMerge (clang::CXXRecordDecl const *, const cling::Interpreter &) |
| | Return true if the class has a method Merge(TCollection*,TFileMergeInfo*)
|
| |
| bool | ROOT::TMetaUtils::HasOldMerge (clang::CXXRecordDecl const *, const cling::Interpreter &) |
| | Return true if the class has a method Merge(TCollection*)
|
| |
| bool | ROOT::TMetaUtils::hasOpaqueTypedef (clang::QualType instanceType, const TNormalizedCtxt &normCtxt) |
| | Return true if the type is a Double32_t or Float16_t or is a instance template that depends on Double32_t or Float16_t.
|
| |
| bool | ROOT::TMetaUtils::hasOpaqueTypedef (const AnnotatedRecordDecl &cl, const cling::Interpreter &interp, const TNormalizedCtxt &normCtxt) |
| | Return true if any of the argument is or contains a double32.
|
| |
| bool | ROOT::TMetaUtils::HasResetAfterMerge (clang::CXXRecordDecl const *, const cling::Interpreter &) |
| | Return true if the class has a method ResetAfterMerge(TFileMergeInfo *)
|
| |
| void | ROOT::TMetaUtils::Info (const char *location, const char *fmt,...) |
| |
| static const std::string | ROOT::TMetaUtils::propNames::ioname ("ioname") |
| |
| static const std::string | ROOT::TMetaUtils::propNames::iotype ("iotype") |
| |
| bool | ROOT::TMetaUtils::IsBase (const clang::CXXRecordDecl *cl, const clang::CXXRecordDecl *base, const clang::CXXRecordDecl *context, const cling::Interpreter &interp) |
| |
| bool | ROOT::TMetaUtils::IsBase (const clang::FieldDecl &m, const char *basename, const cling::Interpreter &interp) |
| |
| bool | ROOT::TMetaUtils::IsHeaderName (const std::string &filename) |
| |
| bool | ROOT::TMetaUtils::IsLinkdefFile (const char *filename) |
| |
| bool | ROOT::TMetaUtils::IsOfType (const clang::CXXRecordDecl &cl, const std::string &type, const cling::LookupHelper &lh) |
| |
| bool | ROOT::TMetaUtils::IsStdClass (const clang::RecordDecl &cl) |
| | Return true, if the decl is part of the std namespace.
|
| |
| bool | ROOT::TMetaUtils::IsStdDropDefaultClass (const clang::RecordDecl &cl) |
| | Return true, if the decl is part of the std namespace and we want its default parameter dropped.
|
| |
| ROOT::ESTLType | ROOT::TMetaUtils::IsSTLCont (const clang::RecordDecl &cl) |
| | type : type name: vector<list<classA,allocator>,allocator> result: 0 : not stl container abs(result): code of container 1=vector,2=list,3=deque,4=map 5=multimap,6=set,7=multiset
|
| |
| int | ROOT::TMetaUtils::IsSTLContainer (const AnnotatedRecordDecl &annotated) |
| | Is this an STL container.
|
| |
| int | ROOT::TMetaUtils::IsSTLContainer (const clang::CXXBaseSpecifier &base) |
| | Is this an STL container?
|
| |
| ROOT::ESTLType | ROOT::TMetaUtils::IsSTLContainer (const clang::FieldDecl &m) |
| | Is this an STL container?
|
| |
| bool | ROOT::TMetaUtils::IsStreamableObject (const clang::FieldDecl &m, const cling::Interpreter &interp) |
| |
| void | ROOT::TMetaUtils::LevelPrint (bool prefix, int level, const char *location, const char *fmt, va_list ap) |
| |
| bool | ROOT::TMetaUtils::MatchWithDeclOrAnyOfPrevious (const clang::CXXRecordDecl &cl, const clang::CXXRecordDecl ¤tCl) |
| | This is a recursive function.
|
| |
| static const std::string | ROOT::TMetaUtils::propNames::name ("name") |
| |
| static const std::string | ROOT::TMetaUtils::propNames::nArgsToKeep ("nArgsToKeep") |
| |
| bool | ROOT::TMetaUtils::NeedDestructor (clang::CXXRecordDecl const *, const cling::Interpreter &) |
| |
| bool | ROOT::TMetaUtils::NeedTemplateKeyword (clang::CXXRecordDecl const *) |
| |
| static const std::string | ROOT::TMetaUtils::propNames::pattern ("pattern") |
| |
| static const std::string | ROOT::TMetaUtils::propNames::persistent ("persistent") |
| |
| int | ROOT::TMetaUtils::AST2SourceTools::PrepareArgsForFwdDecl (std::string &templateArgs, const clang::TemplateParameterList &tmplParamList, const cling::Interpreter &interpreter) |
| | Loop over the template parameters and build a string for template arguments using the fully qualified name There are different cases: Case 1: a simple template parameter E.g.
|
| |
| clang::ClassTemplateDecl * | ROOT::TMetaUtils::QualType2ClassTemplateDecl (const clang::QualType &qt) |
| | Extract from a qualtype the class template if this makes sense.
|
| |
| bool | ROOT::TMetaUtils::QualType2Template (const clang::QualType &qt, clang::ClassTemplateDecl *&ctd, clang::ClassTemplateSpecializationDecl *&ctsd) |
| | Get the template specialisation decl and template decl behind the qualtype Returns true if successfully found, false otherwise.
|
| |
| int | ROOT::TMetaUtils::RemoveTemplateArgsFromName (std::string &name, unsigned int) |
| | Remove the last n template arguments from the name.
|
| |
| void | ROOT::TMetaUtils::ReplaceAll (std::string &str, const std::string &from, const std::string &to, bool recurse=false) |
| |
| bool | ROOT::TMetaUtils::RequireCompleteType (const cling::Interpreter &interp, clang::SourceLocation Loc, clang::QualType Type) |
| |
| bool | ROOT::TMetaUtils::RequireCompleteType (const cling::Interpreter &interp, const clang::CXXRecordDecl *cl) |
| |
| clang::QualType | ROOT::TMetaUtils::ReSubstTemplateArg (clang::QualType input, const clang::Type *instance) |
| | Check if 'input' or any of its template parameter was substituted when instantiating the class template instance and replace it with the partially sugared types we have from 'instance'.
|
| |
| const clang::CXXRecordDecl * | ROOT::TMetaUtils::ScopeSearch (const char *name, const cling::Interpreter &gInterp, bool diagnose, const clang::Type **resultType) |
| | Return the scope corresponding to 'name' or std::'name'.
|
| |
| static const std::string | ROOT::TMetaUtils::propNames::separator ("@@@") |
| |
| void | ROOT::TMetaUtils::SetPathsForRelocatability (std::vector< std::string > &clingArgs) |
| | Organise the parameters for cling in order to guarantee relocatability It treats the gcc toolchain and the root include path FIXME: enables relocatability for experiments' framework headers until PCMs are available.
|
| |
| const char * | ROOT::TMetaUtils::ShortTypeName (const char *typeDesc) |
| | Return the absolute type of typeDesc.
|
| |
| std::string | ROOT::TMetaUtils::ShortTypeName (const clang::FieldDecl &m) |
| | Return the absolute type of typeDesc.
|
| |
| ROOT::ESTLType | ROOT::TMetaUtils::STLKind (const llvm::StringRef type) |
| | Converts STL container name to number. vector -> 1, etc..
|
| |
| void | ROOT::TMetaUtils::SysError (const char *location, const char *fmt,...) |
| |
| static const std::string | ROOT::TMetaUtils::propNames::transient ("transient") |
| |
| std::string | ROOT::TMetaUtils::TrueName (const clang::FieldDecl &m) |
| | TrueName strips the typedefs and array dimensions.
|
| |
| void | ROOT::TMetaUtils::Warning (const char *location, const char *fmt,...) |
| |
| void | ROOT::TMetaUtils::WriteAuxFunctions (std::ostream &finalString, const AnnotatedRecordDecl &cl, const clang::CXXRecordDecl *decl, const cling::Interpreter &interp, const RConstructorTypes &ctorTypes, const TNormalizedCtxt &normCtxt) |
| | std::string NormalizedName; GetNormalizedName(NormalizedName, decl->getASTContext().getTypeDeclType(decl), interp, normCtxt);
|
| |
| void | ROOT::TMetaUtils::WriteClassCode (CallWriteStreamer_t WriteStreamerFunc, const AnnotatedRecordDecl &cl, const cling::Interpreter &interp, const TNormalizedCtxt &normCtxt, std::ostream &finalString, const RConstructorTypes &ctorTypes, bool isGenreflex) |
| | Generate the code of the class If the requestor is genreflex, request the new streamer format.
|
| |
| void | ROOT::TMetaUtils::WriteClassInit (std::ostream &finalString, const AnnotatedRecordDecl &cl, const clang::CXXRecordDecl *decl, const cling::Interpreter &interp, const TNormalizedCtxt &normCtxt, const RConstructorTypes &ctorTypes, bool &needCollectionProxy) |
| | FIXME: a function of 450+ lines!
|
| |
| int | ROOT::TMetaUtils::WriteNamespaceHeader (std::ostream &, const clang::DeclContext *) |
| | Write all the necessary opening part of the namespace and return the number of closing brackets needed For example for Space1::Space2 we write: namespace Space1 { namespace Space2 { and return 2.
|
| |
| int | ROOT::TMetaUtils::WriteNamespaceHeader (std::ostream &, const clang::RecordDecl *) |
| |
| void | ROOT::TMetaUtils::WritePointersSTL (const AnnotatedRecordDecl &cl, const cling::Interpreter &interp, const TNormalizedCtxt &normCtxt) |
| | Write interface function for STL members.
|
| |
