KVClassFactory.h

/*
$Id: KVClassFactory.h,v 1.13 2009/01/21 08:04:20 franklan Exp $
$Revision: 1.13 $
$Date: 2009/01/21 08:04:20 $
*/
 
#ifndef __KVCLASSFACTORY_H
#define __KVCLASSFACTORY_H
 
#include "Riostream.h"
#include "TDatime.h"
#include "TClass.h"
#include "KVString.h"
#include "KVNameValueList.h"
#include "KVList.h"
#include "KVBase.h"
 
 
class KVClassFactory : public TObject {
 
private:
 
    KVString fClassName;
    KVString fClassDesc;
    KVString fBaseClassName;
    TClass* fBaseClass;
    Bool_t fHasBaseClass;
    Bool_t fBaseClassTObject;
    KVString fAuthor;
    TDatime fNow;
    Bool_t fWithTemplate;
    KVString fTemplateBase;
    KVString fTemplateClassName;
    KVString fTemplateH;
    KVString fTemplateCPP;
    KVList fMembers;
    KVList fMethods;
    KVList fHeadInc;
    KVList fImpInc;
    Bool_t fInlineAllMethods;
    Bool_t fInlineAllCtors;
    KVString fClassPath;
    Bool_t fInheritAllCtors;
 
protected:
 
   void WritePreProc(std::ofstream&);
   void WriteWhoWhen(std::ofstream&);
   void SetWhoWhen();
   void WriteClassDec(std::ofstream&);
   void WriteClassHeader();
   void WriteClassImp();
   void WriteClassWithTemplateHeader();
   void WriteClassWithTemplateImp();
   Bool_t CheckTemplateFiles(const Char_t* base_class,
                             const Char_t* templateFile);
 
 
   Ssiz_t FindNextUncommentedLine(TString&, Ssiz_t beg = 0);
   void AddTObjectCopyMethod();
   void AddCopyConstructor();
 
   void GenerateGettersAndSetters();
   void AddAssignmentOperator();
public:
 
   class KVClassMember : public KVBase {
 
   protected:
      KVString fComment;//informative comment for member variable, like this one :)
      KVString fRealName;//the name of the member without the leading 'f'
      Bool_t fIsFundamental=false;//true for fundamental types i.e. basic variables
      Bool_t fIsPointer=false;//true for raw pointer member variables
 
   public:
      KVClassMember()
      {
         SetAccess();
      }
      KVClassMember(const Char_t*, const Char_t*, const Char_t*, const Char_t* = "protected");
      KVClassMember(const KVClassMember&);
      ROOT_COPY_ASSIGN_OP(KVClassMember)
      virtual ~KVClassMember() {}
      void Copy(TObject& obj) const override;
 
      void Print(Option_t* = "") const override;
 
      virtual void WriteDeclaration(KVString&);
 
      void SetAccess(const Char_t* acc = "public")
      {
         SetLabel(acc);
      }
 
      const Char_t* GetAccess() const
      {
         return GetLabel();
      }
      Bool_t IsPublic() const
      {
         return !strcmp(GetAccess(), "public");
      }
      Bool_t IsProtected() const
      {
         return !strcmp(GetAccess(), "protected");
      }
      Bool_t IsPrivate() const
      {
         return !strcmp(GetAccess(), "private");
      }
      Bool_t IsFundamental() const
      {
         return fIsFundamental;
      }
      Bool_t IsPointer() const
      {
         return fIsPointer;
      }
 
      void SetComment(const Char_t* c)
      {
         fComment = c;
      }
 
      const Char_t* GetComment() const
      {
         return fComment;
      }
 
      const Char_t* GetRealName() const
      {
         return fRealName;
      }
 
      ClassDefOverride(KVClassMember, 1) //KVClassFactory helper class - description of class member variable
   };
 
 
   class KVClassMethod : public KVClassMember {
 
   protected:
      virtual void write_method_body(KVString& decl);
      KVNameValueList fFields;//fields of method declaration
      Bool_t fVirtual=false;//kTRUE if method is 'virtual'
      Bool_t fConst=false;//kTRUE if method is 'const'
      int fNargs=0;//counts arguments
      Bool_t fInline=false;//kTRUE if method body is to be written in header file
      Bool_t fNoexcept=false;//kTRUE if method is 'noexcept'
 
      void write_doxygen_format_method_comments(KVString& decl);
 
      public:
 
      Int_t GetNargs() const
      {
         return fNargs;
      }
      void SetNargs(Int_t n)
      {
         fNargs = n;
      }
 
      bool IsNoExcept() const
      {
         return fNoexcept;
      }
      void SetNoExcept(bool yes = true)
      {
         fNoexcept = yes;
      }
 
      KVClassMethod(Bool_t Virtual = kFALSE, Bool_t Const = kFALSE, Bool_t Inline = kFALSE)
         : KVClassMember(), fVirtual(Virtual), fConst(Const), fNargs(0), fInline(Inline)
      {
      }
      KVClassMethod(const KVClassMethod&);
 
      void Copy(TObject& obj) const override;
 
      void SetReturnType(const Char_t* type)
      {
         KVString s(type);
         fFields.SetValue("ReturnType", s);
      }
      void SetClassName(const Char_t* name)
      {
         KVString s(name);
         fFields.SetValue("ClassName", s);
      }
      void SetBaseClass(const Char_t* name)
      {
         KVString s(name);
         fFields.SetValue("BaseClass", s);
      }
      void AddArgument(const Char_t* type, const Char_t* argname = "", const Char_t* defaultvalue = "")
      {
         KVString _type(type);
         fFields.SetValue(Form("Arg_%d", ++fNargs), _type);
         if (strcmp(defaultvalue, "")) {
            KVString _s(defaultvalue);
            fFields.SetValue(Form("Arg_%d_default", fNargs), _s);
         }
         if (strcmp(argname, "")) {
            KVString _s(argname);
            fFields.SetValue(Form("Arg_%d_name", fNargs), _s);
         }
      }
      void AddArgument(Int_t i, const Char_t* type, const Char_t* argname = "", const Char_t* defaultvalue = "");
      void SetMethodBody(const KVString& body)
      {
         fFields.SetValue("Body", body);
      }
      void SetMethodComment(const KVString& com)
      {
         fFields.SetValue("Comment", com);
      }
      const Char_t* GetReturnType()
      {
         if (fFields.HasParameter("ReturnType"))
            return fFields.GetStringValue("ReturnType");
         return "";
      }
      const Char_t* GetClassName()
      {
         return fFields.GetStringValue("ClassName");
      }
 
      void SetConst(Bool_t c = kTRUE)
      {
         fConst = c;
      }
      void SetVirtual(Bool_t c = kTRUE)
      {
         fVirtual = c;
      }
 
      Bool_t IsConst() const
      {
         return fConst;
      }
      Bool_t IsVirtual() const
      {
         return fVirtual;
      }
      virtual Bool_t IsConstructor() const
      {
         return kFALSE;
      }
 
      void Print(Option_t* = "") const override;
 
      void WriteDeclaration(KVString&) override;
      void WriteImplementation(KVString& decl);
 
      void SetInline(Bool_t yes = kTRUE)
      {
         fInline = yes;
      }
      Bool_t IsInline() const
      {
         return fInline;
      }
      virtual Bool_t IsDestructor() const
      {
         return kFALSE;
      }
      Bool_t IsNormalMethod() const
      {
         return (!IsConstructor() && !IsDestructor());
      }
 
      ClassDefOverride(KVClassMethod, 2) //KVClassFactory helper class - description of class method
   };
 
   class KVClassConstructor : public KVClassMethod {
      Bool_t fCopyCtor=false;//kTRUE if method is the copy constructor
      Bool_t fMoveCtor=false;//true if move ctor
      void write_method_body(KVString& decl) override;
      KVClassFactory* fParentClass=nullptr;
 
   public:
      KVClassConstructor(KVClassFactory* ParentClass)
         : KVClassMethod(), fCopyCtor(kFALSE), fParentClass(ParentClass) {};
 
      Bool_t IsConstructor() const override
      {
         return kTRUE;
      }
      Bool_t IsDefaultCtor() const
      {
         return IsCalled("default_ctor");
      }
      Bool_t IsCopyCtor() const
      {
         return fCopyCtor;
      }
      void SetCopyCtor(Bool_t c = kTRUE)
      {
         fCopyCtor = c;
      }
      Bool_t IsMoveCtor() const
      {
         return fMoveCtor;
      }
      void SetMoveCtor(Bool_t c = kTRUE)
      {
         fMoveCtor = c;
      }
      void SetBaseClassArgument(Int_t i)
      {
         fFields.SetValue(Form("Arg_%d_baseclass", i), 1);
      }
      void SetMemberVariableNameForArgument(Int_t i, const Char_t* memvar)
      {
         fFields.SetValue(Form("Arg_%d_memvar", i), memvar);
      }
 
      ClassDefOverride(KVClassConstructor, 1) //KVClassFactory helper class - description of constructor
   };
 
protected:
   void AddMemberInitialiserConstructor(KVClassConstructor* = nullptr);
 
public:
   class KVClassDestructor : public KVClassMethod {
 
   public:
      KVClassDestructor()
         : KVClassMethod(kTRUE)
      {
         SetName("destructor");
         SetMethodComment("Destructor");
      }
      Bool_t IsDestructor() const override
      {
         return kTRUE;
      }
 
      ClassDefOverride(KVClassDestructor, 1) //KVClassFactory helper class - description of destructor
   };
 
   KVClassFactory();
   KVClassFactory(const Char_t* classname,
                  const Char_t* classdesc,
                  const Char_t* base_class =
                     "", Bool_t withTemplate =
                     kFALSE, const Char_t* templateFile = "");
   KVClassFactory(const KVClassFactory&);
 
   void Copy(TObject& obj) const override;
 
   static void MakeClass(const Char_t* classname,
                         const Char_t* classdesc,
                         const Char_t* base_class =
                            "", Bool_t withTemplate =
                            kFALSE, const Char_t* templateFile = "");
   void GenerateCode();
 
   KVClassMember* AddMember(const Char_t* name, const Char_t* type, const Char_t* comment, const Char_t* access = "protected");
   KVClassMethod* AddMethod(const Char_t* name, const Char_t* return_type, const Char_t* access = "public",
                            Bool_t isVirtual = kFALSE, Bool_t isConst = kFALSE);
   KVClassConstructor* AddConstructor(const Char_t* argument_type = "",
                                      const Char_t* argument_name = "", const Char_t* default_value = "", const Char_t* access = "public");
   void AddAllBaseConstructors();
   void AddDefaultConstructor();
   void AddDestructor(const TString& access = "public");
   void AddMethod(const KVClassMethod& kvcm);
   void AddMethodArgument(const Char_t* method_name, const Char_t* argument_type,
                          const Char_t* argument_name = "", const Char_t* default_value = "");
   void AddMethodBody(const Char_t* method_name, const KVString& body);
   void AddMethodComment(const Char_t* method_name, const KVString& comment);
 
   void AddHeaderIncludeFile(const Char_t* filename);
   void AddImplIncludeFile(const Char_t* filename);
 
   const KVList* GetListOfMethods() const
   {
      return &fMethods;
   }
   const KVList* GetListOfMembers() const
   {
      return &fMembers;
   }
   KVClassMethod* GetMethod(const Char_t* name) const
   {
      return fMethods.get_object<KVClassMethod>(name);
   }
   KVClassConstructor* GetDefaultCtor() const
   {
      return (KVClassConstructor*)GetMethod("default_ctor");
   }
   KVClassDestructor* GetDestructor() const
   {
      return (KVClassDestructor*)GetMethod("destructor");
   }
 
   const Char_t* GetClassName() const
   {
      return fClassName.Data();
   }
   void SetClassName(const Char_t* n)
   {
      fClassName = n;
   }
   const Char_t* GetHeaderFileName() const
   {
      return fClassPath != "" ? Form("%s%s.h", fClassPath.Data(), fClassName.Data()) : Form("%s.h", fClassName.Data());
   }
   const Char_t* GetImpFileName() const
   {
      return fClassPath != "" ? Form("%s%s.cpp", fClassPath.Data(), fClassName.Data()) : Form("%s.cpp", fClassName.Data());
   }
   void SetClassDesc(const Char_t* d)
   {
      fClassDesc = d;
   }
   const Char_t* GetClassDesc() const
   {
      return fClassDesc.Data();
   }
   void SetBaseClass(const Char_t* b)
   {
      fBaseClassName = b;
      fHasBaseClass = (fBaseClassName != "");
      fBaseClassTObject = kFALSE;
      if (fHasBaseClass) {
         fBaseClass = TClass::GetClass(fBaseClassName);
         fBaseClassTObject = (fBaseClass && fBaseClass->InheritsFrom("TObject"));
      }
   }
   const Char_t* GetBaseClass() const
   {
      return fBaseClassName.Data();
   }
   Bool_t WithMultipleBaseClasses() const
   {
      return fBaseClassName.Contains(",");
   }
   Bool_t WithTemplate() const
   {
      return fWithTemplate;
   }
   Bool_t IsBaseClassTObject() const
   {
      return fBaseClassTObject;
   }
   void SetTemplate(Bool_t temp, const Char_t* temp_file);
   const Char_t* GetTemplateBase() const
   {
      return fTemplateBase;
   }
   Int_t GetNumberOfMemberVariables() const
   {
      return fMembers.GetEntries();
   }
 
   void Print(Option_t* opt = "") const override;
 
   void AddGetSetMethods(const KVNameValueList&);
 
   void InlineAllMethods(bool yes = true);
   void InlineAllConstructors(bool yes = true);
 
   void SetOutputPath(const KVString& p)
   {
      fClassPath = p;
      if (!fClassPath.EndsWith("/")) fClassPath.Append("/");
   }
   const Char_t* GetOutputPath() const
   {
      return fClassPath;
   }
 
   void SetInheritAllConstructors(Bool_t yes = kTRUE)
   {
      fInheritAllCtors = yes;
   }
 
   Bool_t HasVirtualMethods() const
   {
 
      TIter it(GetListOfMethods());
      KVClassMethod* cm;
      while( ( cm = (KVClassMethod*)it() ))
      {
         if(cm->IsVirtual())
            return kTRUE;
      }
      return kFALSE;
   }
 
   ClassDefOverride(KVClassFactory, 5) //Factory for generating KaliVeda skeleton classes
};
 
#endif