msd_metadata.h

//--------------------------------
// msd_metadata.h
//
// Project: META DATA Classes for PDBe API Framework 
//
// Data Layer
// Last updated: 25 February 2004 10:17
// (C) Siamak Sobhany
//--------------------------------

#ifndef __MSD_METADATA_H__
#define __MSD_METADATA_H__

#ifndef __MSD_DATATYPES_H__
#include "msd_datatypes.h"
#endif
#ifndef __MSD_DATA_H__
#include "msd_data.h"
#endif

struct msd_table 
    { char *name;
          int ID; 
      char *owner; 
      char *description; 
    }; 
    struct TableArray 
        {
      struct msd_table  ptr[42];
      int size; 
    }; 

#define  MakeAPIFunctions(TableName,AttName,TypeName)        \
 void Set##TableName##AttName (##TypeName value) {           \
             AttName = value;                                \
                         };                                              \
 TypeName Get##TableName##AttName () const {return AttName;};                    
 



// Object Attribute introspection

//Steps to do if you want to add support for a new type
// 1:  Add an enumeration to CAttribute::AttributeType
// 2:  Add a typedef to CSetAttribute with the signiture of the function pointer for the set operation
// 3:  Add a type from the above typedef to CSetAttribute's FunctionPointers union
// 4:  Add a constructor to CSetAttribute to handle the new function pointer typedef
// 5:  Overload CSetAttribute::SetAttribute so that it takes a first parameter of your new type
// 6:  repeate 2-5 for CGetAttribute
// 7:  Add the appropriate macros to handle your new type :SET_yourtype_GET_ATTRIBUTE,SET_yourtype_SET_ATTRIBUTE,SET_yourtype_ATTRIBUTE
#include <list>
//using std::list;
//


//used locally to simplify calling function pointers
#define CallMemberFunction(object,ptrToMember)  ((object)->*(ptrToMember)) 

class CAttribute
{
public:
        enum AttributeType
        {
                ATInt,
                ATShort,
                ATDouble,
                ATString,
                ATFloat,
                ATBool,
                ATDate

        };
        

// Function name        : CAttribute
// Description      : The only constructor for CAttribute
// Return type          : 
// Argument         : LPCTSTR sName
// Argument         : AttributeType iType
        CAttribute(char* sName,AttributeType iType):m_sName(sName),m_Type(iType){};

        char* GetName(){return m_sName;};
        const AttributeType GetType(){return m_Type;};

protected:
        char*           m_sName;
        AttributeType   m_Type;
        
private:
        CAttribute();
};

template<class DerivedClass> class CSetAttribute : public CAttribute
{
public:
        typedef void (DerivedClass::*intfp)(int);
    typedef void (DerivedClass::*shortfp)(short);
        typedef void (DerivedClass::*doublefp)(double);
        typedef void (DerivedClass::*stringfp)(const char*&);
        typedef void (DerivedClass::*floatfp)(float);
        typedef void (DerivedClass::*boolfp)(bool);
        typedef void (DerivedClass::*datefp)(msdbDate);

        union FunctionPointers
        {
                 intfp IntSetfp;
                 doublefp DoubleSetfp;
                 stringfp StringSetfp;
                 floatfp FloatSetfp;
                 boolfp BoolSetfp;
                 datefp DateSetfp;
        };

        CSetAttribute(char* sName,AttributeType iType,intfp p):CAttribute(sName,iType){m_uFunctionPointer.IntSetfp=p;};
        CSetAttribute(char* sName,AttributeType iType,shortfp p):CAttribute(sName,iType){m_uFunctionPointer.ShortSetfp=p;}
        CSetAttribute(char* sName,AttributeType iType,doublefp p):CAttribute(sName,iType){m_uFunctionPointer.DoubleSetfp=p;}
        CSetAttribute(char* sName,AttributeType iType,stringfp p):CAttribute(sName,iType){m_uFunctionPointer.StringSetfp=p;};
        CSetAttribute(char* sName,AttributeType iType,floatfp p):CAttribute(sName,iType){m_uFunctionPointer.FloatSetfp=p;};
        CSetAttribute(char* sName,AttributeType iType,boolfp p):CAttribute(sName,iType){m_uFunctionPointer.BoolSetfp=p;};
        CSetAttribute(char* sName,AttributeType iType,datefp p):CAttribute(sName,iType){m_uFunctionPointer.DareSetfp=p;};
        
        void SetAttribute(int Val,DerivedClass* p)
        {
                CallMemberFunction(p,m_uFunctionPointer.IntSetfp)(Val);
        };
        void SetAttribute(short Val,DerivedClass* p)
        {
                CallMemberFunction(p,m_uFunctionPointer.ShortSetfp)(Val);
        };
        void SetAttribute(double Val,DerivedClass* p)
        {
                CallMemberFunction(p,m_uFunctionPointer.DoubleSetfp)(Val);
        };
        void SetAttribute(char* Val,DerivedClass* p)
        {
                CallMemberFunction(p,m_uFunctionPointer.StringSetfp)(Val);
        };
        void SetAttribute(float Val,DerivedClass* p)
        {
                CallMemberFunction(p,m_uFunctionPointer.FloatSetfp)(Val);
        };
        void SetAttribute(bool Val,DerivedClass* p)
        {
                CallMemberFunction(p,m_uFunctionPointer.BoolSetfp)(Val);
        };
        void SetAttribute(msdbDate Val,DerivedClass* p)
        {
                CallMemberFunction(p,m_uFunctionPointer.DateSetfp)(Val);
        };

        CSetAttribute(char* sName,AttributeType iType):CAttribute(sName,iType){};
private:
        CSetAttribute();
        FunctionPointers  m_uFunctionPointer;
};


//class that represents all of the get function pointers in your derived class  
template<class DerivedClass> class CGetAttribute: public CAttribute
{

public:
        typedef int (DerivedClass::*intfp)(void) const;
    typedef short (DerivedClass::*shortfp)(void) const;
        typedef double (DerivedClass::*doublefp)(void) const;
        typedef char* (DerivedClass::*stringfp)(void) const;
        typedef float (DerivedClass::*floatfp)(void) const;
        typedef bool (DerivedClass::*boolfp)(void) const;
        typedef msdbDate (DerivedClass::*datefp)(void) const;

        union FunctionPointers
        {
                 intfp IntGetfp;
                 shortfp ShortGetfp;
                 doublefp DoubleGetfp;
                 stringfp StringGetfp;
                 floatfp FloatGetfp;
                 boolfp BoolGetfp;
                 datefp DateGetfp;
                
        };
        CGetAttribute(char* sName,AttributeType iType,intfp p):CAttribute(sName,iType){m_uFunctionPointer.IntGetfp=p;};
        CGetAttribute(char* sName,AttributeType iType,shortfp p):CAttribute(sName,iType){m_uFunctionPointer.ShortGetfp=p;};
        CGetAttribute(char* sName,AttributeType iType,doublefp p):CAttribute(sName,iType){m_uFunctionPointer.DoubleGetfp=p;};
        CGetAttribute(char* sName,AttributeType iType,stringfp p):CAttribute(sName,iType){m_uFunctionPointer.StringGetfp=p;};
        CGetAttribute(char* sName,AttributeType iType,floatfp p):CAttribute(sName,iType){m_uFunctionPointer.FloatGetfp=p;};
        CGetAttribute(char* sName,AttributeType iType,boolfp p):CAttribute(sName,iType){m_uFunctionPointer.BoolGetfp=p;};
        CGetAttribute(char* sName,AttributeType iType,datefp p):CAttribute(sName,iType){m_uFunctionPointer.DateGetfp=p;};

        void GetAttribute(DerivedClass* p, int& Val)
        {
                Val = CallMemberFunction(p,m_uFunctionPointer.IntGetfp )();
        };
        void GetAttribute(DerivedClass* p, short& Val)
        {
                Val = CallMemberFunction(p,m_uFunctionPointer.ShortGetfp )();
        };
        void GetAttribute(DerivedClass* p, double& Val)
        {
                Val = CallMemberFunction(p,m_uFunctionPointer.DoubleGetfp )();
        };
        void GetAttribute(DerivedClass* p, char*& Val)
        {
                Val = CallMemberFunction(p,m_uFunctionPointer.StringGetfp )();
        };
        void GetAttribute(DerivedClass* p, float& Val)
        {
                Val = CallMemberFunction(p,m_uFunctionPointer.FloatGetfp )();
        };
        void GetAttribute(DerivedClass* p, bool& Val)
        {
                Val = CallMemberFunction(p,m_uFunctionPointer.BoolGetfp )();
        };
        void GetAttribute(DerivedClass* p, msdbDate& Val)
        {
                Val = CallMemberFunction(p,m_uFunctionPointer.DateGetfp )();
        };

        CGetAttribute(char* sName,AttributeType iType):CAttribute(sName,iType){};
private:
        CGetAttribute();
        FunctionPointers  m_uFunctionPointer;
};


//classes that wish to expose their attributes must inherit from this class
// to implement, inherit from CExposeAttributes<yourclass>
// each attribute you want to expose must have a get and set function
// in your class's constructor, identify all attributes by using the appropriate macro
//   eg:  SET_INT_ATTRIBUTE(youclass,name of your attribute, function name for the set function, function name for the get function)
//   if you only have a get function, then you can expose that by using SET_INT_GET_ATTRIBUTE(youclass,name of your attribute,function name for the get function)
//##ModelId=3DCBF9AF02E6
template<class DerivedClass> class CExposeAttributes 
{
        typedef std::list< CGetAttribute<DerivedClass> > GET_ATTRIBUTE_LIST;
        typedef std::list< CSetAttribute<DerivedClass> > SET_ATTRIBUTE_LIST;
        typedef typename GET_ATTRIBUTE_LIST::iterator GET_ATTRIBUTE_LIST_ITERATOR;
        typedef typename SET_ATTRIBUTE_LIST::iterator SET_ATTRIBUTE_LIST_ITERATOR;
        

public:
        GET_ATTRIBUTE_LIST GetGetAttributes();
        SET_ATTRIBUTE_LIST GetSetAttributes();

        CGetAttribute<DerivedClass>* GetNextGetAttribute(bool bBegin=false)
        {
                if (m_Gets.empty())
                        return NULL;

                if (bBegin)
                {
                        m_iGets = m_Gets.begin();
                        return &(*m_iGets);
                }

                m_iGets++;
                if (m_iGets == m_Gets.end()) 
                        return NULL;

                return &(*m_iGets);
        };
        CSetAttribute<DerivedClass>* GetNextSetAttribute(bool bBegin=false)
        {
                if (m_Sets.empty())
                        return NULL;

                if (bBegin)
                {
                        m_iSets = m_Sets.begin();
                        return &(*m_iSets);
                }

                m_iSets++;
                if (m_iSets == m_Sets.end()) 
                        return NULL;

                return &(*m_iSets);
        };
        virtual void AddGetAttribute(const CGetAttribute<DerivedClass>& oAtt){m_Gets.push_back(oAtt);};
        virtual void AddSetAttribute(const CSetAttribute<DerivedClass>& oAtt){m_Sets.push_back(oAtt);};
protected:
        GET_ATTRIBUTE_LIST m_Gets;
    GET_ATTRIBUTE_LIST_ITERATOR m_iGets;
        SET_ATTRIBUTE_LIST m_Sets;
        SET_ATTRIBUTE_LIST_ITERATOR m_iSets;
};
        

//int macros
#define SET_INT_GET_ATTRIBUTE(classname,name,memberfunction) \
        {CGetAttribute<classname> oAtt(name,CAttribute::ATInt,memberfunction); \
        AddGetAttribute(oAtt);}
#define SET_INT_SET_ATTRIBUTE(classname,name,memberfunction) \
        {CSetAttribute<classname> oAtt(name,CAttribute::ATInt,memberfunction); \
        AddSetAttribute(oAtt);}
#define SET_INT_ATTRIBUTE(classname,name,setfunction,getfunction) SET_INT_SET_ATTRIBUTE(classname,name,setfunction) SET_INT_GET_ATTRIBUTE(classname,name,getfunction)


//double macros
#define SET_DOUBLE_GET_ATTRIBUTE(classname,name,memberfunction) \
        {CGetAttribute<classname> oAtt(name,CAttribute::ATDouble,memberfunction); \
        AddGetAttribute(oAtt);}
#define SET_DOUBLE_SET_ATTRIBUTE(classname,name,memberfunction) \
        {CSetAttribute<classname> oAtt(name,CAttribute::ATDouble,memberfunction); \
        AddSetAttribute(oAtt);}
#define SET_DOUBLE_ATTRIBUTE(classname,name,setfunction,getfunction) SET_DOUBLE_SET_ATTRIBUTE(classname,name,setfunction) SET_DOUBLE_GET_ATTRIBUTE(classname,name,getfunction)

//short macros
#define SET_SHORT_GET_ATTRIBUTE(classname,name,memberfunction) \
        {CGetAttribute<classname> oAtt(name,CAttribute::ATShort,memberfunction); \
        AddGetAttribute(oAtt);}
#define SET_SHORT_SET_ATTRIBUTE(classname,name,memberfunction) \
        {CSetAttribute<classname> oAtt(name,CAttribute::ATShort,memberfunction); \
        AddSetAttribute(oAtt);}
#define SET_SHORT_ATTRIBUTE(classname,name,setfunction,getfunction) SET_SHORT_SET_ATTRIBUTE(classname,name,setfunction) SET_SHORT_GET_ATTRIBUTE(classname,name,getfunction)


//char String macros
#define SET_STRING_GET_ATTRIBUTE(classname,name,memberfunction) \
        {CGetAttribute<classname> oAtt(name,CAttribute::ATString,memberfunction); \
        AddGetAttribute(oAtt);}
#define SET_STRING_SET_ATTRIBUTE(classname,name,memberfunction) \
        {CSetAttribute<classname> oAtt(name,CAttribute::ATString,memberfunction); \
        AddSetAttribute(oAtt);}
#define SET_STRING_ATTRIBUTE(classname,name,setfunction,getfunction) SET_STRING_SET_ATTRIBUTE(classname,name,setfunction) SET_STRING_GET_ATTRIBUTE(classname,name,getfunction)

//Float macros
#define SET_FLOAT_GET_ATTRIBUTE(classname,name,memberfunction) \
        {CGetAttribute<classname> oAtt(name,CAttribute::ATFloat,memberfunction); \
        AddGetAttribute(oAtt);}
#define SET_FLOAT_SET_ATTRIBUTE(classname,name,memberfunction) \
        {CSetAttribute<classname> oAtt(name,CAttribute::ATFloat,memberfunction); \
        AddSetAttribute(oAtt);}
#define SET_FLOAT_ATTRIBUTE(classname,name,setfunction,getfunction) SET_FLOAT_SET_ATTRIBUTE(classname,name,setfunction) SET_FLOAT_GET_ATTRIBUTE(classname,name,getfunction)

//bool macros
#define SET_BOOL_GET_ATTRIBUTE(classname,name,memberfunction) \
        {CGetAttribute<classname> oAtt(name,CAttribute::ATBool,memberfunction); \
        AddGetAttribute(oAtt);}
#define SET_BOOL_SET_ATTRIBUTE(classname,name,memberfunction) \
        {CSetAttribute<classname> oAtt(name,CAttribute::ATBool,memberfunction); \
        AddSetAttribute(oAtt);}
#define SET_BOOL_ATTRIBUTE(classname,name,setfunction,getfunction) SET_BOOL_SET_ATTRIBUTE(classname,name,setfunction) SET_BOOL_GET_ATTRIBUTE(classname,name,getfunction)

//Date macros
#define SET_DATE_GET_ATTRIBUTE(classname,name,memberfunction) \
        {CGetAttribute<classname> oAtt(name,CAttribute::ATDate,memberfunction); \
        AddGetAttribute(oAtt);}
#define SET_DATE_SET_ATTRIBUTE(classname,name,memberfunction) \
        {CSetAttribute<classname> oAtt(name,CAttribute::ATDate,memberfunction); \
        AddSetAttribute(oAtt);}
#define SET_DATE_ATTRIBUTE(classname,name,setfunction,getfunction) SET_DATE_SET_ATTRIBUTE(classname,name,setfunction) SET_DATE_GET_ATTRIBUTE(classname,name,getfunction)




int WriteTableAttributes(char* schema, char* connstr, char* fname);
int MSDAPIGenerator(char* schema, char* connstr, char* fname);
int SoapDataGenerator(char* schema, char* connstr, char* fname);
void get_info(char * schema, struct TableArray * p2ta, char* liststr);
int GetTablesRelations(char* schema, struct TableArray * p2ta ,char* connstr);
int GetDataModel(char* schema, struct TableArray * p2ta ,char* connstr);
int LoadMetaData(char* schema,char* connstr);
int MSDStructureModel(void);

#endif //__MSD_METADATA_H__

---