DoBase.hpp

// Copyright (c) 2007, Arne Steinarson
// Licensing for DynObj project - see DynObj-license.txt in this folder

#ifndef DOBASE_HPP
#define DOBASE_HPP

#include <string.h>

// Basic interfaces
#include "DoBaseI.h"
#include "DoError.h"

// Include DynShared support
#if DO_USE_DYNSHARED==1
    #include "DoDynShared.hpp"
#endif


// Doxygen stuff

// This compile-time assert is adopted from Boost
template<bool b>
struct DoErrorIfNot;

template<>
struct DoErrorIfNot<true>{ };

#define DO_ASSERT(cond) sizeof(DoErrorIfNot<cond>)

// Peel off pointers, refs & const
template <class T>
struct DoBaseType {
    typedef T type;
};

template <class T>
struct DoBaseType<T*> {
    typedef typename DoBaseType<T>::type type;
};

template <class T>
struct DoBaseType<T&> {
    typedef typename DoBaseType<T>::type type;
};

template <class T>
struct DoBaseType<const T> {
    typedef typename DoBaseType<T>::type type;
};


// Simple test for same type
template <class T, class U>
struct IsSameType {
    enum { v=false };
};

template <class T>
struct IsSameType<T,T> {
    enum { v=true };
};


// Tests if a class has a VTable or not
template<class T>
struct IsVObjImpl {
    struct IA : public T {
        int m;
    };
    struct IB : public T {
        virtual void F( );
        int m;
    };
    enum { v = (sizeof(IA)==sizeof(IB)) };
};



template<class T>
struct IsVObj {
    typedef typename DoBaseType<T>::type type;
    enum { v=IsVObjImpl<type>::v || IsSameType<VObj,type>::v };
};



/*
template<class T>
struct IsVObj<T*> {
    enum { v = IsVObj<T>::v };
};

template<class T>
struct IsVObj<T&> {
    enum { v = IsVObj<T>::v };
};
*/

// This avoids long error messages for the void case
template<>
struct IsVObj<void> {
    enum { v = false };
};

// Is a class derived from DynI?

// This adds a level for resolving ambigous base classes.
// (Override and specify primary base class)
template <class T>
struct VBaseSelect {
    typedef T type;
};

template <class T, class U>
struct DoIsTypeAImpl {
    // Test functions
    static char F( U* );
    static short F(...);
    static T* pt;
    enum { v=sizeof(F(pt))==sizeof(char) };
};

template <class T, class U>
struct DoIsTypeA {
    typedef typename DoBaseType<T>::type BT;
    typedef typename VBaseSelect<BT>::type VBST;
    enum { v=DoIsTypeAImpl<VBST,U>::v };
    //enum { v=DoIsTypeAImpl<typename DoBaseType<T>::type,U>::v };
};



// Check if type is const
template <class T>
struct DoIsConst {
    enum { v=0 };
};

template <class T>
struct DoIsConst<const T> {
    enum { v=1 };
};

template <class T>  // Should this be needed?
struct DoIsConst<const T&> {
    enum { v=1 };
};

template <class T>  // Should this be needed?
struct DoIsConst<const T*> {
    enum { v=1 };
};


// Check if type is a ref or not
template <class T>
struct DoIsRef {
    enum { v=0 };
};

template <class T>
struct DoIsRef<T&> {
    enum { v=1 };
};


// Check if type is a pointer or not
template <class T>
struct DoIsPointer {
    enum { v=0 };
};

template <class T>
struct DoIsPointer<T*> {
    enum { v=1 };
};


// Helper to do a fast (static cast) or a DynObj cast when needed
template <class T, class U, bool is_t>
struct DoCasterSelect;

// Case where T can be statically casted to U
template<class T, class U>
struct DoCasterSelect<T,U,true> {
    static U* Cast(T* pt,DynObjType *pdt){ return pt; }
};

// Case where we need to do a DynObj cast 
template<class T, class U>
struct DoCasterSelect<T,U,false> {
    static U* Cast(T* pt, DynObjType *pdt){ 
        return (U*)::doGetObj(pt,doTypeInfo<U>::Id(),pdt);
    }
};


// Casting based on type ID:s
template<class U, int M, int N>
struct DoCaster;    // Generic case, compile time error

template<class U, int N>
struct DoCaster<U,0,N> {    // Case for detected VObj
    static U Cast( const void *pv, doCastAlgo algo ){
        if( !pv ) return 0;
        return reinterpret_cast<U>(::doGetObj((void*)pv,doTypeInfo<U>::Id(),NULL,algo));
    }
};

template<class U, int N>
struct DoCaster<U,1,N> {    // Case for DynI
    static U Cast( const DynI *pdi, doCastAlgo algo ) {
        if( !pdi ) return 0;
        return reinterpret_cast<U>(::doGetObj((void*)pdi,doTypeInfo<U>::Id(),DI_GET_TYPE(pdi),algo));
    }
};

#if DO_USE_DYNSHARED==1
template<class U, int N>
struct DoCaster<U,N,1> {    // Case for RTDynShared
    static U Cast( const RTDynShared *prtds, doCastAlgo algo ) {
        if( !prtds ) return 0;
        // Return pointer to self?
        if( IsSameType<U,DynSharedI>::v ||
            IsSameType<U,DynI>::v ||
            IsSameType<U,VObj>::v ) return prtds;
        else
            return DoCaster<U,2,0>::Cast( prtds, algo );
    }
};
#else // DO_USE_DYNSHARED
    // Provide dummy template class for test below
    struct RTDynShared { };
#endif


// Type-string case (for do_cast_str)
template<class U, int M, int N>
struct DoCasterStr; // Generic case, compile time error

template<class U, int N>
struct DoCasterStr<U,0,N> { // Case for detected VObj
    static U Cast( const void *pv, doCastAlgo algo ){
        if( !pv ) return 0;
        return reinterpret_cast<U>(::doGetObj((void*)pv,doTypeInfo<U>::Name(),NULL,algo));
    }
};

template<class U, int N>
struct DoCasterStr<U,1,N> { // Case for DynI
    static U Cast( const DynI *pdi, doCastAlgo algo ) {
        if( !pdi ) return 0;
        return reinterpret_cast<U>(::doGetObj((void*)pdi,doTypeInfo<U>::Name(),DI_GET_TYPE(pdi),algo));
    }
};

#if DO_USE_DYNSHARED==1
template<class U, int N>
struct DoCasterStr<U,N,1> { // Case for RTDynShared
    static U Cast( const RTDynShared *prtds, doCastAlgo algo ) {
        if( !prtds ) return 0;
        // Return pointer to self?
        if( IsSameType<U,DynSharedI>::v ||
            IsSameType<U,DynI>::v ||
            IsSameType<U,VObj>::v ) return prtds;
        else
            return DoCasterStr<U,2,0>::Cast( prtds, algo );
    }
};
#endif




template<class U, class T>
U do_cast( T* pt, doCastAlgo algo=doCastFull ) {
    // OK when we have positive on IsVObj or IsDynI,
    // negative when both are false (compile time error, we
    // cannot cast from the type).
    // Verify constness first (compile time)
    DO_ASSERT( DoIsConst<U>::v || !DoIsConst<T>::v );
    DO_ASSERT( IsVObj<T>::v );
    return DoCaster< U, DoIsTypeA<T,DynI>::v, 
                    DoIsTypeA<T,RTDynShared>::v >
                    ::Cast((typename VBaseSelect<T>::type*)pt,algo);
}

template<class U, class T>
U do_cast_ref( T& t, doCastAlgo algo=doCastFull ) {
    // Verify constness first (compile time)
    DO_ASSERT( (int)DoIsConst<U>::v >= (int)DoIsConst<T>::v );
    DO_ASSERT( IsVObj<T>::v );
    // Then cast
    return *DoCaster< typename DoBaseType<U>::type*, 
                      DoIsTypeA<T,DynI>::v, 
                      DoIsTypeA<T,RTDynShared>::v >
                      ::Cast((typename VBaseSelect<T>::type*)&t,algo);
}



template<class U, class T>
U do_cast_str( T* pt, doCastAlgo algo=doCastFull ) {
    // Verify constness first (compile time)
    DO_ASSERT( DoIsConst<U>::v || !DoIsConst<T>::v );
    DO_ASSERT( IsVObj<T>::v );
    return DoCasterStr< U, DoIsTypeA<T,DynI>::v, 
                        DoIsTypeA<T,RTDynShared>::v >
                        ::Cast((typename VBaseSelect<T>::type*)pt,algo);
}

template<class U, class T>
U do_cast_ref_str( T& t, doCastAlgo algo=doCastFull ) {
    // Verify constness first (compile time)
    DO_ASSERT( (int)DoIsConst<U>::v >= (int)DoIsConst<T>::v );
    DO_ASSERT( IsVObj<T>::v );
    return *DoCasterStr< typename DoBaseType<U>::type*, 
                         DoIsTypeA<T,DynI>::v, 
                         DoIsTypeA<T,RTDynShared>::v >
                         ::Cast((typename VBaseSelect<T>::type*)&t,algo);
}



template<class T>
VObj *to_vobj( T t ) {
    DO_ASSERT( IsVObj<T>::v );
    return reinterpret_cast<VObj*>(t);
}

template<class T>
VObj &to_vobj( T& t ) {
    DO_ASSERT( IsVObj<T>::v );
    return reinterpret_cast<VObj&>(t);
}


template<class T>
struct doTypeWrapper{ };



// DynData - temporary arbitrary type data holder
//
#include <string.h>
#include <assert.h>

#include "DoTypeBase.hpp"

#define DYNDATA_MAX_SIZE sizeof(double)

// %%DYNOBJ class(dyni) flags(notypeid,inst2reg)
class DynData : public DynI {
public:
    DynObjType* docall doGetType( const DynI **pself ) const;

    DynData( ) : m_type(0) { }


    template<class T>
    DynData( T t ) {
        // Check that size is OK
        DO_ASSERT( sizeof(T) <= DYNDATA_MAX_SIZE );

        m_type = DoFullType2Int<T>::Id();

        // Fill up with 0 or -1 if signed
        memset( m_data, ((m_type&DOT_TYPE_MASK)==DOT_SINT)?-1:0, DYNDATA_MAX_SIZE );

#ifdef PFM_BIG_ENDIAN
        // Motorola style, value stored at end
        *(T*)(m_data+DYNDATA_MAX_SIZE-sizeof(T)) = t;
#else
        // Intel style, value always stored first
        *(T*)m_data = t;
#endif
    }

    int GetType(){ return m_type; }

    template<class T>
    bool IsA() const {
        int type = DoFullType2Int<T>::Id();
        if( type==UNKNOWN_TYPE_ID ) return false;

        if( type==m_type ||             // Exactly the same type
            type==(m_type|DOT_CONST) )  // or a const version is asked for
            return true;

        // If wrong pointer/ref level, we fail
        if( DOT_PTR_REF_LEVEL(type)!=DOT_PTR_REF_LEVEL(m_type) ) return false;

        // OK const-ness? Out must be equal or more const
        if( !(type&DOT_CONST) && (m_type&DOT_CONST) ) return false;

        // Request for a user-type ?
        if( !(type&DOT_PRIMITIVE) ){
            // If we are a primitive type, fail.
            if( m_type&DOT_PRIMITIVE ) return false;

            // We check if the requested type is a direct base class of ours
            DynObjType *dot = doFindType(m_type&TYPE_ID_MASK);
            if( !dot ){
                VObj::SetError( "DynData::IsA - Failed looking up DynObjType", m_type );
                return false;
            }
            // This asks type from callers module. 
            // See if we have this class as a main base class
            return dot->IsA( type&TYPE_ID_MASK, NULL );
        }

        // If we are a user type, the only primitive type we can convert
        // to is const void* or bool
        if( !(m_type&DOT_PRIMITIVE) ) {
            // Must be pointer or ref
            if( !(m_type&(DOT_PTR_MASK|DOT_REF)) ) return false;
            return type==DoType2Int<const void*>::v ||
                   type==DoType2Int<bool>::v;
        }

        // Both are primitive types

        // Same base type? (char/signed int/unsigned int)
        if( (type&DOT_TYPE_MASK)==(m_type&DOT_TYPE_MASK) ){
            // We can expand a small integer/char to a larger one
            if( (type&DOT_SIZE_MASK)>=(m_type&DOT_TYPE_MASK) )
                return true;
            // We could also check that our value is in the requested range
            // That is really a run-time check
            // I.e int(5) could be casted to unsigned int
            // but int(-2) could not
        }

        return false;
    }

    template<class T>
    T Get() const {
        bool b = IsA<T>();
        assert( b ); // # Is this a good solution? Maybe better to set object error.
        // We must request either a const reference or
        // not a reference at all.
        DO_ASSERT( DoIsConst<T>::v ||
                   !(DoIsRef<T>::v && !DoIsPointer<T>::v) );

#ifdef PFM_BIG_ENDIAN
        // Motorola style, value stored at end
        return *reinterpret_cast<const T*>(m_data+DYNDATA_MAX_SIZE-sizeof(T));
#else
        // Intel style, value always stored first
        return *reinterpret_cast<const T*>(m_data);
#endif
    }

/*
    // Basically we want the same signature without args.
    double GetDouble() const {
        assert( m_type&DOT_TYPE_MASK==DOT_FLOAT );
        switch( m_type&DOT_SIZE_MASK ){
#ifdef PFM_BIG_ENDIAN
            case DOT_SIZE_8: return (double)*reinterpret_cast<const float*>(m_data+DYNDATA_MAX_SIZE-sizeof(double));
#else
            case DOT_SIZE_8: return *reinterpret_cast<const double*>(m_data);
#endif

#ifdef PFM_BIG_ENDIAN
            case DOT_SIZE_4: return (double)*reinterpret_cast<const float*>(m_data+DYNDATA_MAX_SIZE-sizeof(float));
#else
            case DOT_SIZE_4: return (double)*reinterpret_cast<const float*>(m_data);
#endif
            default: assert(0);
        }
        return 0.0;
    }
*/
    // We could also provide:
    //   bool CanBeA()
    // and
    //   T Extract()
    // which would allow for converting/lossy casts

protected:
    int m_type;
    union {
        char m_data[DYNDATA_MAX_SIZE];
        const char* m_str;      // For debugging convenience
    };
};


template<class T>
struct doKeepRef {
    doKeepRef( T& t ) : m_t(t) { }
    operator T& (){ return m_t; }
    T& m_t;
};


template<class I>
void do_try( DynI *pdi, void (docall I::*func)() ){
    I *pi = do_cast<I*>(pdi);
    if( pi ) (pi->*func)();
}
template<class I, class RV>
RV do_try( DynI *pdi, RV (docall I::*func)(), RV rv=0 ){
    I *pi = do_cast<I*>(pdi);
    if( !pi ) return rv;
    return (pi->*func)();
}

template<class I, class A1, class _A1>
void do_try( DynI *pdi, void (docall I::*func)(A1), _A1 a1 ){
    I *pi = do_cast<I*>(pdi);
    if( pi ) (pi->*func)(a1);
}
template<class I, class RV, class A1, class _A1>
RV do_try( DynI *pdi, RV (docall I::*func)(A1), _A1 a1, RV rv=0 ){
    I *pi = do_cast<I*>(pdi);
    if( !pi ) return rv;
    return (pi->*func)(a1);
}

template<class I, class A1, class A2,
                  class _A1, class _A2>
void do_try( DynI *pdi, void (docall I::*func)(A1,A2), _A1 a1, _A2 a2 ){
    I *pi = do_cast<I*>(pdi);
    if( pi ) (pi->*func)(a1,a2);
}
template<class I, class RV, class A1, class A2,
                            class _A1, class _A2>
RV do_try( DynI *pdi, RV (docall I::*func)(A1,A2), _A1 a1, _A2 a2, RV rv=0 ){
    I *pi = do_cast<I*>(pdi);
    if( !pi ) return rv;
    return (pi->*func)(a1,a2);
}

template<class I, class A1, class A2, class A3,
                  class _A1, class _A2, class _A3>
void do_try( DynI *pdi, void (docall I::*func)(A1,A2,A3), _A1 a1, _A2 a2, _A3 a3 ){
    I *pi = do_cast<I*>(pdi);
    if( pi ) (pi->*func)(a1,a2,a3);
}
 // No args, return value
template<class I, class RV, class A1, class A2, class A3,
                            class _A1, class _A2, class _A3>
RV do_try( DynI *pdi, RV (docall I::*func)(A1,A2,A3), _A1 a1, _A2 a2, _A3 a3, RV rv=0 ){
    I *pi = do_cast<I*>(pdi);
    if( !pi ) return rv;
    return (pi->*func)(a1,a2,a3);
}


/***************************************************************
 * @ingroup DynTemplate
 * A couple of wrapper class to automatically call doConstruct on
 * created instances. Can be used both for statics/globals or for
 * objects that are instantiated with ordinary C++ new.
 **************************************************************/

// These are the same
#define doConstrGlob doConstructGlobal 

template<class T>
struct doConstructGlobal {
    doConstructGlobal( )
        : m_t() {
        Construct();
    }
    template<class A>
    doConstructGlobal( A arg )
        : m_t(arg) {
        Construct();
    }

    /* object access, reference */
    T& operator -> (){ return m_t; }
    /* object access, reference */
    operator T&(){ return m_t; }
    /* object access, pointer */
    operator T*(){ return &m_t; }

protected:
    bool Construct( ){
        bool rv = true;
        DynI *pdi = NULL;
        DynObjType *pdt = m_t.doGetType((const DynI**)&pdi);
        DO_ASSERT_MSG(&m_t==reinterpret_cast<T*>(pdi),"Should be outermost type");
        //if( &m_t!=reinterpret_cast<T*>(pdi) )
        //  rv = false; // Warning
        if( !pdt )
            rv = false; // Warning
        else {
            // If we come here before the DynObjType constructor has been 
            // run, delay calling doConstruct (can be done since we're 
            // handling a global)
            if( !pdt->_sh.IsOk() )
                rv = ::doConstructDelayed( &m_t, pdt );
            else {
                rv = ::doConstruct( &m_t, pdt, NULL );
                // What can happen is that we have unresolved internal bases,
                // halfway into construction. Then redo later.
                if( !rv )
                    rv = ::doConstructDelayed( &m_t, pdt );
            }
        }
        return rv;
    }

    T m_t;
};

// These are the same
#define doConstrLoc doConstructLocal 

template<class T>
struct doConstructLocal {
    doConstructLocal( ){
        m_pt = new T();
        Construct();
    }
    template<class A>
    doConstructLocal( A arg ){
        m_pt = new T(arg);
        Construct();
    }

    ~doConstructLocal(){
        delete m_pt;
    }

    /* Release ownership of object */
    T* Release(){
        T* pt = m_pt;
        m_pt = NULL;
        return pt;
    }

    /* object access, reference */
    T& operator -> (){ return *m_pt; }
    /* object access, reference */
    operator T&(){ return *m_pt; }
    /* object access, pointer */
    operator T*(){ return m_pt; }

protected:
    bool Construct( ){
        if( !m_pt ) return false;
        bool rv = true;
        DynI *pdi = NULL;
        DynObjType *pdt = m_pt->doGetType((const DynI**)&pdi);
        if( !pdt )
            rv=false; // Warning
        if( m_pt!=reinterpret_cast<T*>(pdi) )
            rv=false; // Warning

        // Avoid calling doConstruct when not needed
        void **vtbl = *(void***)m_pt;
        if( vtbl!=st_vtbl_last ){
            st_vtbl_last = vtbl;
            rv &= ::doConstruct( m_pt, pdt, NULL );
        }
        return rv;
    }

    T *m_pt;
    static void** st_vtbl_last;
};

template<class T>
void** doConstructLocal<T>::st_vtbl_last;


// %%DYNOBJ section general
// This section is auto-generated and manual changes will be lost when regenerated!!
#ifdef DO_IMPLEMENT_DOBASE
    #define DO_IMPLEMENTING     // If app has not defined it already
#endif
#include "dynobj/DynObj.h"

// --- Forward class declarations ---
class DynData;

// --- For each declared class, doTypeInfo template specializations ---
DO_DECL_TYPE_INFO(DynData,DYNDATA_TYPE_ID);

// %%DYNOBJ section end



// %%DYNOBJ section implement
// This section is auto-generated and manual changes will be lost when regenerated!!
#ifdef DO_IMPLEMENT_DOBASE

// Generate type information that auto-registers on module load
DynObjTypeI2R<DynData,DynI,false> g_do_vtype_DynData("DynData:DynI",DYNDATA_TYPE_ID,1);
DynObjType* DynData::doGetType( const DynI **pself ) const {
   if(pself) *pself=(const DynI*)(const void*)this;
   return &g_do_vtype_DynData;
}
#endif //DO_IMPLEMENT_...
// %%DYNOBJ section end

#endif //DOBASE_HPP

---