TSchemaRule.h

Go to the documentation of this file.

// @(#)root/core:$Id$
// author: Lukasz Janyst <ljanyst@cern.ch>
 
#ifndef ROOT_TSchemaRule
#define ROOT_TSchemaRule
 
#include "TNamed.h"
#include "TString.h"
 
#include <vector>
#include <utility>
 
class TBuffer;
class TVirtualObject;
class TObjArray;
namespace ROOT {
namespace Internal {
struct TSchemaHelper;
}
} // namespace ROOT
 
namespace ROOT {
 
   class TSchemaRule : public TObject
   {
      public:
 
         class TSources : public TNamed {
         private:
            TString fDimensions;
            Int_t fPointerLevel = 0;
 
         public:
            TSources(const char *name = nullptr, const char *title = nullptr, const char *dims = nullptr)
               : TNamed(name, title), fDimensions(dims)
            {
               if (fTitle.Length())
                  while (fTitle[fTitle.Length() - fPointerLevel - 1] == '*')
                     ++fPointerLevel;
               if (fPointerLevel)
                  fTitle.Remove(fTitle.Length() - fPointerLevel);
            }
 
            const char *GetDimensions() const { return fDimensions; }
 
            bool IsPointer() const { return fPointerLevel > 0; }
 
            Int_t GetPointerLevel() const { return fPointerLevel; }
 
            const char *GetUnderlyingTypeName() const { return fTitle; }
 
            // The source can be declared with:
            //   "%s %s%s;", GetTypeForDeclaration().Data(), GetName(), GetDimensions);
            TString GetTypeForDeclaration()
            {
               TString type = fTitle;
               for (Int_t s = 0; s < fPointerLevel; ++s)
                  type.Append('*');
               return type;
            }
 
            void SetTitle(const char *) override
            {
               Fatal("SetTitle", "Changing the type represented by a TSources is not supported.");
            }
 
            ClassDefOverride(TSources, 3);
         };
 
         typedef enum
         {
            kReadRule    = 0,
            kReadRawRule = 1,
            kNone        = 99999
         }  RuleType_t;
 
         typedef void (*ReadFuncPtr_t)( char*, TVirtualObject* );
         typedef void (*ReadRawFuncPtr_t)( char*, TBuffer&);
 
         TSchemaRule();
         TSchemaRule(RuleType_t type, const char *targetClass, const ROOT::Internal::TSchemaHelper &helper);
         virtual ~TSchemaRule();
 
         TSchemaRule( const TSchemaRule& rhs );
         TSchemaRule& operator = ( const TSchemaRule& rhs );
         Bool_t operator == ( const TSchemaRule& rhs ) const;
 
 
         void             Clear(Option_t * /*option*/ ="") override;
         Bool_t           SetFromRule( const char *rule );
 
         const char      *GetVersion( ) const;
         Bool_t           SetVersion( const TString& version );
         Bool_t           TestVersion( Int_t version ) const;
         Bool_t           SetChecksum( const TString& checksum );
         Bool_t           TestChecksum( UInt_t checksum ) const;
         void             SetSourceClass( const TString& classname );
         const char      *GetSourceClass() const;
         void             SetTargetClass( const TString& classname );
         const char      *GetTargetClass() const;
         void             SetTarget( const TString& target );
         const TObjArray* GetTarget() const;
         const char      *GetTargetString() const;
         void             SetSource( const TString& source );
         const TObjArray* GetSource() const;
         void             SetEmbed( Bool_t embed );
         Bool_t           GetEmbed() const;
         Bool_t           IsAliasRule() const;
         Bool_t           IsRenameRule() const;
         Bool_t           IsValid() const;
         void             SetCode( const TString& code );
         const char      *GetCode() const;
         void             SetAttributes( const TString& attributes );
         const char      *GetAttributes() const;
         Bool_t           HasTarget( const TString& target ) const;
 
         Bool_t           HasSource( const TString& source ) const;
         void             SetReadFunctionPointer( ReadFuncPtr_t ptr );
         ReadFuncPtr_t    GetReadFunctionPointer() const;
         void             SetReadRawFunctionPointer( ReadRawFuncPtr_t ptr );
         ReadRawFuncPtr_t GetReadRawFunctionPointer() const;
         void             SetInclude( const TString& include );
         const TObjArray* GetInclude() const;
         void             SetRuleType( RuleType_t type );
         RuleType_t       GetRuleType() const;
         Bool_t           Conflicts( const TSchemaRule* rule ) const;
 
         void             AsString( TString &out, const char *options = "" ) const;
         void             ls(Option_t *option="") const override;
 
      private:
 
         Bool_t ProcessVersion( const TString& version ) const;
         Bool_t ProcessChecksum( const TString& checksum ) const;
         UInt_t ParseChecksum( const char* checksum ) const;
         static void ProcessList( TObjArray* array, const TString& list );
         static void ProcessDeclaration( TObjArray* array, const TString& list );
 
         TString                      fVersion;        //  Source version string
         mutable std::vector<std::pair<Int_t, Int_t> >* fVersionVect;    ///<! Source version vector (for searching purposes)
         TString                      fChecksum;       //  Source checksum string
         mutable std::vector<UInt_t>* fChecksumVect;   ///<! Source checksum vector (for searching purposes)
         TString                      fSourceClass;    //  Source class
         TString                      fTargetClass;    //  Target class, this is the owner of this rule object.
         TString                      fTarget;         //  Target data mamber string
         mutable TObjArray*           fTargetVect;     ///<! Target data member vector (for searching purposes)
         TString                      fSource;         //  Source data member string
         mutable TObjArray*           fSourceVect;     ///<! Source data member vector (for searching purposes)
         TString                      fInclude;        //  Includes string
         mutable TObjArray*           fIncludeVect;    ///<! Includes vector
         TString                      fCode;           //  User specified code snippet
         Bool_t                       fEmbed;          //  Value determining if the rule should be embedded
         ReadFuncPtr_t                fReadFuncPtr;    ///<! Conversion function pointer for read rule
         ReadRawFuncPtr_t             fReadRawFuncPtr; ///<! Conversion function pointer for readraw rule
         RuleType_t                   fRuleType;       //  Type of the rule
         TString                      fAttributes;     //  Attributes to be applied to the member (like Owner/NotOwner)
 
      ClassDefOverride( TSchemaRule, 1 );
 
   };
} // End of namespace ROOT
 
#endif // ROOT_TSchemaRule