Has dictionary

core/meta/inc/TClass.h

@@ -33,8 +33,10 @@
 #ifndef ROOT_TObjString
 #include "TObjString.h"
 #endif
+
 #include <map>
 #include <string>
+#include <set>
 
 class TBaseClass;
 class TBrowser;
@@ -308,6 +310,7 @@ friend class ROOT::TGenericClassInfo;
    TVirtualStreamerInfo     *GetStreamerInfo(Int_t version=0) const;
    TVirtualStreamerInfo     *GetStreamerInfoAbstractEmulated(Int_t version=0) const;
    const type_info   *GetTypeInfo() const { return fTypeInfo; };
+   std::set<TClass*>  GetMissingClassDictionaries(bool recurse);
    void               IgnoreTObjectStreamer(Bool_t ignore=kTRUE);
    Bool_t             InheritsFrom(const char *cl) const;
    Bool_t             InheritsFrom(const TClass *cl) const;

core/meta/inc/TInterpreter.h

@@ -26,6 +26,8 @@
 #include "TDictionary.h"
 #endif
 
+#include <set>
+
 class TClass;
 class TEnv;
 class TFunction;
@@ -73,6 +75,7 @@ class TInterpreter : public TNamed {
    virtual const char *GetIncludePath() = 0;
    virtual const char *GetSTLIncludePath() const { return ""; }
    virtual TObjArray  *GetRootMapFiles() const = 0;
+   virtual std::set<TClass*> GetMissingDictionaries(TClass* cl, bool recurse) = 0;
    virtual void     Initialize() = 0;
    virtual void     InspectMembers(TMemberInspector&, void* obj, const TClass* cl) = 0;
    virtual Bool_t   IsLoaded(const char *filename) const = 0;

core/meta/src/TClass.cxx

@@ -3159,6 +3159,14 @@ void TClass::GetMenuItems(TList *list)
    }
 }
 
+std::set<TClass*> TClass::GetMissingClassDictionaries(bool recurse)
+{
+   //Get the classes that have a missing dictionary.
+
+   std::set<TClass*> clMissingDict = gInterpreter->GetMissingDictionaries(this, recurse);
+   return clMissingDict;
+}
+
 //______________________________________________________________________________
 Bool_t TClass::IsFolder(void *obj) const
 {

core/meta/src/TCling.cxx

@@ -2753,6 +2753,122 @@ const char* TCling::GetInterpreterTypeName(const char* name, Bool_t full)
    return result.c_str();
 }
 
+//______________________________________________________________________________
+namespace UNNAMED {
+   void GetMissingDictionariesForDecl(const clang::Decl* D, std::set<const clang::Decl*> &netD, bool recurse)
+   {
+      // Get the data members that do not have a dictionary for a Decl.
+
+      // Get the name of the class
+      std::string buf;
+      if (const NamedDecl* ND = llvm::dyn_cast<NamedDecl>(D)) {
+         PrintingPolicy Policy(ND->getASTContext().getPrintingPolicy());
+         llvm::raw_string_ostream stream(buf);
+         ND->getNameForDiagnostic(stream, Policy, /*Qualified=*/false);
+      }
+      const char* name = buf.c_str();
+
+      // Check for the dictionary of the curent class.
+      if (!gClassTable->GetDict(name)){
+         std::set<const clang::Decl*>::iterator it = netD.find(D);
+         if (it != netD.end()) return ;
+         netD.insert(D);   
+         if(!recurse) return ;
+      }
+      else return ;
+
+      if (const clang::CXXRecordDecl* RD = llvm::dyn_cast<clang::CXXRecordDecl>(D)) {
+      // Recurse for the data members.
+      for (clang::RecordDecl::field_iterator iField = RD->field_begin(),
+        eField = RD->field_end(); iField != eField; ++iField) {
+
+               clang::QualType qualType = (*iField)->getType();
+               if (!qualType.isNull()) {
+
+               //Repetion of code will be fixed with next commit.
+               //class 
+               if (qualType->isRecordType()) {
+                  if(clang::CXXRecordDecl* FD = qualType->getAsCXXRecordDecl()) {
+                     GetMissingDictionariesForDecl(FD, netD, recurse);
+                  }   
+               }
+               //pointer to class or to array or reference
+               if (qualType->isPointerType() || qualType->isReferenceType()) {
+                  QualType pointeeType = qualType->getPointeeType();
+                  if (pointeeType->isRecordType()) {
+                     if(clang::CXXRecordDecl* FD = pointeeType->getAsCXXRecordDecl()) {
+                     GetMissingDictionariesForDecl(FD, netD, recurse);
+                  }   
+                  }   
+                  else if(pointeeType->isArrayType()) {
+                     clang::CXXRecordDecl* FD = pointeeType->getAsCXXRecordDecl();
+                     const Type* elementType = pointeeType->getArrayElementTypeNoTypeQual();
+                     if (elementType->isRecordType()) {
+                        if(clang::CXXRecordDecl* FD = elementType->getAsCXXRecordDecl()) {
+                     GetMissingDictionariesForDecl(FD, netD, recurse);
+                  }   
+                     }            
+                  }
+               }
+               //array of class elements
+               if (qualType->isArrayType()) {
+                  const Type* elementType = qualType->getArrayElementTypeNoTypeQual();
+                  if (elementType->isRecordType()) {
+                     clang::CXXRecordDecl* FD = elementType->getAsCXXRecordDecl();
+                     GetMissingDictionariesForDecl(FD, netD, recurse);
+                  }
+               }
+            }   
+      }   
+   }
+      return ;
+   }
+}
+//______________________________________________________________________________
+std::set<TClass*> TCling::GetMissingDictionaries(TClass* cl, bool recurse /*recurse*/)
+{
+   // Get the Tclass-s that do not have a dictionary.
+
+   // Get the Decl for the class.
+   TClingClassInfo* cli = (TClingClassInfo*)cl->GetClassInfo();
+   const clang::Decl* D = cli->GetDecl();
+
+   // Get the Decls recursively for all data members of TClass cl
+
+   std::set<const clang::Decl*> netD;
+   // Convert to RecordDecl.
+   if (const clang::RecordDecl* RD = llvm::dyn_cast<clang::RecordDecl>(D)) {
+      UNNAMED::GetMissingDictionariesForDecl(RD, netD, recurse);
+   }   
+
+   std::set<TClass*> classesMissingDict;
+
+   //convert set<Decl> to set<TClass>
+   for (std::set<const clang::Decl*>::const_iterator I = netD.begin(),
+           E = netD.end(); I != E; ++I) {
+      // Get name of the class.
+      std::string buf;
+      if (const NamedDecl* ND = llvm::dyn_cast<NamedDecl>(*I)) {
+         PrintingPolicy Policy(ND->getASTContext().getPrintingPolicy());
+         llvm::raw_string_ostream stream(buf);
+         ND->getNameForDiagnostic(stream, Policy, /*Qualified=*/true);
+      }
+      const char* name = buf.c_str();
+      if (TClass* clMissingDict = TClass::GetClass(name)) {
+         classesMissingDict.insert(clMissingDict);
+      } else {
+         Error("TCling::GetMissingDictionaries", "The class %s missing dictionary was not found.", name);
+      }
+   }
+
+   //return the classes the have missing dictionaries
+
+   if (netD.empty()) {
+      classesMissingDict.insert(0);
+   }   
+   return classesMissingDict;
+}
+
 //______________________________________________________________________________
 void TCling::Execute(const char* function, const char* params, int* error)
 {

core/meta/src/TCling.h

@@ -137,6 +137,8 @@ class TCling : public TInterpreter {
    const char* GetIncludePath();
    virtual const char* GetSTLIncludePath() const;
    TObjArray*  GetRootMapFiles() const { return fRootmapFiles; }
+   void    GetMissingDictionariesForDecl(const clang::Decl* D, std::set<const clang::Decl*> netD, bool recurse);
+   std::set<TClass*> GetMissingDictionaries(TClass* cl, bool recurse);
    virtual void Initialize();
    void    InspectMembers(TMemberInspector&, void* obj, const TClass* cl);
    Bool_t  IsLoaded(const char* filename) const;