amorph.h

Go to the documentation of this file.

#include <iostream> // for noise

#include <wibble/mixin.h>
#include <wibble/cast.h>
#include <wibble/maybe.h>
#include <wibble/sfinae.h>
#include <wibble/test.h>

#ifndef WIBBLE_AMORPH_H
#define WIBBLE_AMORPH_H

namespace wibble {

template< typename _T >
struct ReturnType {
    typedef _T T;
};

template<>
struct ReturnType< void > {
    typedef Unit T;
};

template< typename F, typename R >
struct SanitizeReturn {
    inline typename ReturnType< R >::T call(
        typename F::argument_type a )
    {
        return f( a );
    };
};


template< typename F >
struct SanitizeReturn< F, void > {
    inline Unit call( typename F::argument_type a )
    {
        f( a );
        return Unit();
    }
};

template< int A >
struct IsZero {
    static const bool value = false;
};

template<>
struct IsZero< 0 > {
    static const bool value = true;
};

template< typename T >
struct IsPolymorphic {
    struct A : T {
        virtual ~A();
    };
    struct B : T {};
    static const bool value = IsZero< sizeof( A ) - sizeof( B ) >::value;
};

template< typename F >
struct SanitizeResultType {
    SanitizeResultType( F _f ) : f( _f ) {}
    typedef typename ReturnType< typename F::result_type >::T result_type;

    result_type operator()( typename F::argument_type a ) {
        return SanitizeReturn< F, typename F::result_type >().call( a );
    }


    F f;
};

#ifndef SWIG_I
struct Baseless {};

struct VirtualBase {
    virtual ~VirtualBase() {}
};

template< typename Interface >
struct MorphInterface : public Interface {
    virtual VirtualBase *virtualBase() { return 0; }
    virtual MorphInterface *constructCopy( void *where = 0, unsigned int available = 0 ) const = 0;
    virtual void destroy( unsigned int available = 0 ) = 0;
    virtual ~MorphInterface() {}
    virtual bool leq( const MorphInterface * ) const = 0;
};

struct MorphAllocator {
    void *operator new( size_t bytes, void *where, unsigned available ) {
        if ( bytes > available || where == 0 ) {
            where = ::operator new( bytes );
            return where;
        }
        return where;
    }
    void *operator new( size_t bytes ) {
        return ::operator new( bytes );
    }
};

template< typename W, typename Interface >
struct MorphBase : MorphInterface< Interface > {
    MorphBase( const W &w ) : m_wrapped( w ) {}

    template< typename _W >
    typename EnableIf< IsPolymorphic< _W >, VirtualBase *>::T virtualBase() {
        return dynamic_cast< VirtualBase * >( &m_wrapped );
    }

    template< typename _W >
    typename EnableIf< TNot< IsPolymorphic< _W > >, VirtualBase *>::T
    virtualBase() {
        return 0;
    }

    virtual VirtualBase *virtualBase() {
        return virtualBase< W >();
    }

    W &wrapped() {
        return m_wrapped;
    }

protected:
    W m_wrapped;
};

template< typename Self, typename W, typename Interface >
struct Morph : MorphBase< W, Interface >,
    mixin::Comparable< Morph< Self, W, Interface > >,
    MorphAllocator
{
    typedef W Wrapped;

    Morph( const Wrapped &w ) : MorphBase< W, Interface >( w ) {}

    const Self &self() const { return *static_cast< const Self * >( this ); }

    bool operator<=( const Morph &o ) const {
        return wrapped().operator<=( o.wrapped() );
    }

    // evaluation of correctness of definition should be done
    virtual bool leq( const MorphInterface< Interface > *_o ) const {
        const Morph *o = dynamic_cast< const Morph * >( _o );
        if ( !o ) {
            if ( typeid( Morph ).before( typeid( _o ) ) )
                return true;
            else
                return false;
        }
        return wrapped() <= o->wrapped();
    }

    virtual MorphInterface< Interface > *constructCopy(
        void *where, unsigned int available ) const
    {
        return new( where, available ) Self( self() );
    }

    virtual void destroy( unsigned int available ) {
        if ( sizeof( Morph ) <= available ) {
            this->~Morph();
        } else {
            delete this;
        }
    }

    const Wrapped &wrapped() const {
        return this->m_wrapped;
    }

    Wrapped &wrapped() {
        return this->m_wrapped;
    }

    virtual ~Morph() {}
};
#endif

#ifndef WIBBLE_AMORPH_PADDING
#define WIBBLE_AMORPH_PADDING 0
#endif
template<int Padding1> class AmorphPadder
{
    int m_padding[ Padding1 ];
};
template<> class AmorphPadder<0>
{
};

template< typename Self, typename _Interface, int Padding = WIBBLE_AMORPH_PADDING >
struct Amorph {
    typedef _Interface Interface;
    // typedef MorphInterface< Interface > Morp;

    template <typename T> struct Convert {
        typedef T type;
    };

    /* Amorph( const Interface &b ) {
        setInterfacePointer( &b );
        } */

    Amorph( const MorphInterface< Interface > &b ) {
        setMorphInterfacePointer( &b );
    }

    Amorph( const Amorph &a ) {
        setMorphInterfacePointer( a.morphInterface() );
        // setInterfacePointer( a.implementation() );
    }

    Amorph() : m_impl( 0 ) {}

    const Self &self() const {
        return *static_cast< const Self * >( this );
    }

    Self &self() {
        return *static_cast<Self *>( this );
    }

    bool leq( const Self &i ) const {
        if ( morphInterface() )
            if ( i.morphInterface() )
                return morphInterface()->leq( i.morphInterface() );
            else
                return false; // it's false that non-0 <= 0
        else
            return !i.morphInterface(); // 0 <= 0 holds, but 0 <=
                                        // non-0 doesn't
    }

    bool operator<=( const Self &i ) const { return leq( i ); }

    void setInterfacePointer( const Interface *i ) {
        if ( !i ) {
            m_impl = 0;
            return;
        }

        /* assert( dynamic_cast< const MorphInterface * >( i ) );
        assert( dynamic_cast< const Interface * >(
        dynamic_cast< const MorphInterface * >( i ) ) ); */

        m_impl = dynamic_cast< const MorphInterface< Interface > * >( i )->constructCopy(
            &m_padding, sizeof( m_padding ) );

        // assert( dynamic_cast< const Interface * >( m_impl ) );
    }

    void setMorphInterfacePointer( const MorphInterface< Interface > *i ) {
        if ( !i ) {
            m_impl = 0;
            return;
        }
        m_impl = i->constructCopy( &m_padding, sizeof( m_padding ) );
    }

    Amorph &operator=( const Amorph &i ) {
        setInterfacePointer( i.implementation() );
        return *this;
    }

    ~Amorph() {
        if ( morphInterface() )
            morphInterface()->destroy( sizeof( m_padding ) );
    }

    template< typename F >
    Maybe< typename F::result_type > ifType( F func ) {
        typedef typename F::argument_type T;
        typedef Maybe< typename F::result_type > rt;
        T *ptr = impl<T>();
        if (ptr) {
            return rt::Just( func(*ptr) );
        }
        return rt::Nothing();
    }

    const Interface *implementation() const {
        // return dynamic_cast< const Interface * >( m_impl );
        return static_cast< const Interface * >( m_impl );
    }

    Interface *implementation() {
        // return dynamic_cast< Interface * >( m_impl );
        return static_cast< Interface * >( m_impl );
    }

    MorphInterface< Interface > *morphInterface() const {
        return m_impl;
        // return dynamic_cast< MorphInterface< * >( m_impl );
    }

    const Interface &wrapped() const {
        return *implementation();
    }

    Interface &wrapped() {
        return *implementation();
    }

    template< typename T >
    bool is() const {
        return impl< T >();
    }

    bool isVoid() const { return !m_impl; }

    template< typename T >
    T *impl() const {
        T *p = dynamic_cast< T * >( m_impl );
        if ( !p ) {
            MorphBase< T, Interface > *m = dynamic_cast< MorphBase< T, Interface > * >( m_impl );
            if ( m ) p = &(m->wrapped());
        }
        if ( !p ) {
            p = dynamic_cast< T * >( morphInterface()->virtualBase() );
        }
        return p;
    }

private:
    unsigned int reservedSize() { return sizeof( m_padding ) + sizeof( m_impl ); }
    AmorphPadder<Padding> m_padding;
    MorphInterface< Interface > *m_impl;
    // Interface *m_impl;
};

#ifndef SWIG_I
template< typename T, typename X >
typename X::template Convert<T>::type &downcast( const X &a )
{
    return *a.template impl< T >();
}

#endif

}

#endif