---

at_unionptr.h

Go to the documentation of this file.

//
// The Austria library is copyright (c) Gianni Mariani 2004.
// 
// Grant Of License.  Grants to LICENSEE the non-exclusive right to use the Austria
// library subject to the terms of the LGPL.
// 
// A copy of the license is available in this directory or one may be found at this URL:
//      http://www.gnu.org/copyleft/lesser.txt
// 
#ifndef x_at_unionptr_h_x
#define x_at_unionptr_h_x 1

#include "at_types.h"

#include "at_assert.h"

// Austria namespace
namespace at
{

// ======== AT_UnionPtr_Empty =========================================
class UnionPtr_Empty_A
{
};

class UnionPtr_Empty_B
{
};



// ======== UnionPtr ===============================================
template <
    typename    w_enum_type,
    typename    w_type_0,
    typename    w_type_1,
    typename    w_type_2 = UnionPtr_Empty_A,
    typename    w_type_3 = UnionPtr_Empty_B
>
class UnionPtr
{
    public:


    // ======== t_PtrUnion ============================================
    union t_PtrUnion
    {
        w_type_0                                  m_value_0;
        w_type_1                                  m_value_1;
        w_type_2                                  m_value_2;
        w_type_3                                  m_value_3;
        PtrDiff                                   m_ptr_diff;
    };

    t_PtrUnion                                    m_value;


    // ======== t_Check ===============================================
    private:
    struct t_Check
    {
        char m_array_overflow[
            1/ int( !(
                sizeof( t_PtrUnion ) != sizeof( PtrDiff )
                || ( sizeof( ( static_cast< t_PtrUnion * >( 0 ) )->m_value_0 ) < 4 )
                || ( sizeof( ( static_cast< t_PtrUnion * >( 0 ) )->m_value_1 ) < 4 )
            ) )
        ];
    };
    

    public:
    // ======== Get ===================================================
    inline w_enum_type Get(
        w_type_0                & o_param_0,
        w_type_1                & o_param_1,
        w_type_2                & o_param_2 = ( * static_cast< UnionPtr_Empty_A * >( 0 ) ),
        w_type_3                & o_param_3 = ( * static_cast< UnionPtr_Empty_B * >( 0 ) )
    ) const
    {

        t_PtrUnion l_ptr = m_value;

        int l_type = m_value.m_ptr_diff & PtrDiff( 0x3 );

        if ( l_type == 0 )
        {
            o_param_0 = m_value.m_value_0;
            return static_cast<w_enum_type>( 0 );
        }
        
        l_ptr.m_ptr_diff &= ~PtrDiff( 0x3 );

        switch ( l_type )
        {
            case 1 : o_param_1 = l_ptr.m_value_1; return static_cast<w_enum_type>( 1 );
            case 2 : o_param_2 = l_ptr.m_value_2; return static_cast<w_enum_type>( 2 );
            default : o_param_3 = l_ptr.m_value_3; return static_cast<w_enum_type>( 3 );
        }

    } // end Get

    inline UnionPtr & operator=( const w_type_0 i_value )
    {
        m_value.m_value_0 = i_value;
        
        return * this;
    }
    
    inline UnionPtr & operator=( const w_type_1 i_value )
    {
        t_PtrUnion l_ptr;

        l_ptr.m_value_1 = i_value;

        l_ptr.m_ptr_diff |= PtrDiff( 0x1 );

        m_value = l_ptr;

        return * this;
    }
    
    inline UnionPtr & operator=( const w_type_2 i_value )
    {
        t_PtrUnion l_ptr;

        l_ptr.m_value_2 = i_value;

        l_ptr.m_ptr_diff |= PtrDiff( 0x2 );

        m_value = l_ptr;

        return * this;
    }
    
    inline UnionPtr & operator=( const w_type_3 i_value )
    {
        t_PtrUnion l_ptr;

        l_ptr.m_value_3 = i_value;

        l_ptr.m_ptr_diff |= PtrDiff( 0x3 );

        m_value = l_ptr;

        return * this;
    }
    
    inline bool operator==( const UnionPtr & i_value ) const
    {
        return m_value.m_value_0 == i_value.m_value.m_value_0;
    }
    
    inline UnionPtr()
    {
    }
    
    inline UnionPtr( const w_type_0 i_value )
    {
        m_value.m_value_0 = i_value;
        
    }
    
    inline UnionPtr( const w_type_1 i_value )
    {
        t_PtrUnion l_ptr;

        l_ptr.m_value_1 = i_value;

        l_ptr.m_ptr_diff |= PtrDiff( 0x1 );

        m_value = l_ptr;

    }
    
    inline UnionPtr( const w_type_2 i_value )
    {
        t_PtrUnion l_ptr;

        l_ptr.m_value_2 = i_value;

        l_ptr.m_ptr_diff |= PtrDiff( 0x2 );

        m_value = l_ptr;

    }
    
    inline UnionPtr( const w_type_3 i_value )
    {
        t_PtrUnion l_ptr;

        l_ptr.m_value_3 = i_value;

        l_ptr.m_ptr_diff |= PtrDiff( 0x3 );

        m_value = l_ptr;
        
    }
    
};



// ======== UnionPtrType ===========================================
template <
    typename    w_enum_type,
    typename    w_type_0,
    typename    w_type_1
>
class UnionPtrType
{
    public:


    // ======== t_PtrUnion ============================================
    union t_PtrUnion
    {
        w_type_0                                  m_value_0;
        w_type_1                                  m_value_1;
        PtrDiff                                m_ptr_diff;
    };

    t_PtrUnion                                    m_value;


    // ======== t_Check ===============================================
    private:
    struct t_Check
    {
        char    m_array_overflow[
            1/ int( !(
                sizeof( t_PtrUnion ) != sizeof( PtrDiff )
                || ( sizeof( ( static_cast< t_PtrUnion * >( 0 ) )->m_value_0 ) < 4 )
                || ( sizeof( ( static_cast< t_PtrUnion * >( 0 ) )->m_value_1 ) < 4 )
            ) )
        ];
    };
    
    public:
    // ======== Get ===================================================
    inline w_enum_type Get(
        w_type_0                                & o_param_0,
        w_type_1                                & o_param_1
    ) const
    {

        t_PtrUnion l_ptr = m_value;

        int l_type = m_value.m_ptr_diff & PtrDiff( 0x3 );

        if ( l_type == 0 )
        {
            o_param_0 = m_value.m_value_0;
            return static_cast<w_enum_type>( 0 );
        }
        
        l_ptr.m_ptr_diff &= ~PtrDiff( 0x3 );

        o_param_1 = l_ptr.m_value_1;

        return static_cast<w_enum_type>( l_type );


    } // end Get

    inline UnionPtrType & operator=( const w_type_0 i_value )
    {
        m_value.m_value_0 = i_value;
        
        return * this;
    }
    
    inline bool operator==( const UnionPtrType & i_value ) const
    {
        return m_value.m_value_0 == i_value.m_value.m_value_0;
    }
    
    inline UnionPtrType & operator=( const w_type_1 i_value )
    {
        t_PtrUnion l_ptr;

        l_ptr.m_value_1 = i_value;

        l_ptr.m_ptr_diff |= PtrDiff( 0x1 );

        m_value = l_ptr;

        return * this;
    }
    
    inline UnionPtrType()
    {
    }
    
    inline UnionPtrType( const w_type_0 i_value )
    {
        m_value.m_value_0 = i_value;
        
    }
    
    inline UnionPtrType( const w_type_1 i_value )
    {
        t_PtrUnion l_ptr;

        l_ptr.m_value_1 = i_value;

        l_ptr.m_ptr_diff |= PtrDiff( 0x1 );

        m_value = l_ptr;

    }
    
    inline UnionPtrType & Set( const w_type_1 i_value, w_enum_type i_type )
    {
        t_PtrUnion l_ptr;

        AT_Assert( i_type != 0 );

        l_ptr.m_value_1 = i_value;

        l_ptr.m_ptr_diff |= PtrDiff( i_type );

        m_value = l_ptr;

        return * this;
    }
    
};

}; // namespace
#endif // x_at_unionptr_h_x

Generated for Austria by and MakeXS at Sun Oct 24 17:35:34 PDT 2004