---

at_pointers.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_pointers_h_x
#define x_at_pointers_h_x 1


#include "at_os.h"
#include "at_assert.h"

// Austria namespace
namespace at
{

// ======== PointerRange ===========================================
enum PointerRange
{
        Null,
        
        Invalid,
        
        Valid
        
};




// ======== IteratorWrapper ========================================
template <typename w_T, typename w_value_type, bool w_debug_code>
class IteratorWrapper
{
        public:

        enum {
                e_debug_code = ( w_debug_code && OSTraitsBase::DebugBuild ) ? 1 : 0
        };


        typedef w_value_type            value_type;

        IteratorWrapper()
                : m_range( Null )
        {
        }

        IteratorWrapper( const w_T & i_value )
          : m_value( i_value ),
                m_range( Valid )
        {
        }
        

        // ======== Assign ================================================
        inline IteratorWrapper Assign( w_T & i_in )
        {
                IteratorWrapper retval( * this );

                m_range = Valid;

                m_value = i_in;

                return retval;

        } // end Assign

        // ======== AssignNull ============================================
        inline void AssignNull()
        {
                m_range = Null;

        } // end AssignNull

        // ======== AssignInvalid =========================================
        inline void AssignInvalid()
        {
                m_range = Invalid;

        } // end AssignInvalid


        // ======== IsNull ================================================
        inline bool IsNull() const
        {

                if ( e_debug_code )
                {
                        AT_Assert( m_range != Invalid );                        
                }

                return m_range == Null;

        } // end IsNull

        
        // ======== IsValid ===============================================
        inline bool IsValid() const
        {
                return m_range == IsValid;

        } // end IsValid


        // ======== Get ===================================================
        inline const w_T & Get() const
        {

                return m_value;

        } // end GetPtr

        
        protected:
        
        w_T                                                     m_value;
        PointerRange                            m_range;
                
};



// ======== PointerWrapper =========================================
template <typename w_TD, bool w_debug_code>
class PointerWrapper
{

        enum {
                e_debug_code = ( w_debug_code && OSTraitsBase::DebugBuild ) ? 1 : 0
        };

        w_TD                            * m_value;
        
        public:

        typedef w_TD            value_type;

        PointerWrapper( w_TD * i_value = 0 )
          : m_value( i_value )
        {
        }
        

        // ======== Assign ================================================
        inline void Assign( w_TD * i_in )
        {
                m_value = i_in;

        } // end Assign

        // ======== AssignNull ============================================
        inline void AssignNull()
        {
                m_value = 0;

        } // end AssignNull

        // ======== AssignInvalid =========================================
        inline void AssignInvalid()
        {
                m_value = e_debug_code ? ( reinterpret_cast<w_TD *>( -1 ) ) : 0;

        } // end AssignInvalid


        // ======== IsNull ================================================
        inline bool IsNull() const
        {
                if ( e_debug_code )
                {
                        AT_Assert( m_value != ( reinterpret_cast<w_TD *>( -1 ) ) );
                }
                
                return m_value == 0;
                
        } // end IsNull

        
        // ======== IsValid ===============================================
        inline bool IsValid() const
        {

                if ( e_debug_code )
                {
                        if ( m_value == ( reinterpret_cast<w_TD *>( -1 ) ) )
                        {
                                return false;
                        }
                }

                return m_value != 0;

        } // end IsValid


        // ======== Get ===================================================
        inline const w_TD * Get() const
        {
                // don't worry about assertion silliness.
                if ( e_debug_code )
                {
                        AT_Assert( m_value != ( reinterpret_cast<w_TD *>( -1 ) ) );
                }
                
                return m_value;

        } // end GetPtr

        // ======== GetInnerAddr ============================================
        inline w_TD ** GetInnerAddr()
        {
                return & m_value;

        } // end GetPtr

};


// ======== PointerTo ==============================================
template <typename w_T>
class PointerTo
{
    public:

    typedef typename w_T::value_type value_type;

        typedef IteratorWrapper< w_T, value_type, true >                t_pointer_traits_debug;
        typedef IteratorWrapper< w_T, value_type, false >       t_pointer_traits_nodebug;
};



// ======== PointerTo ==============================================
template <typename w_TD>
class PointerTo<w_TD *>
{
    public:

    typedef w_TD value_type;

        typedef PointerWrapper< w_TD, true >            t_pointer_traits_debug;
        
        typedef PointerWrapper< w_TD, false >   t_pointer_traits_nondebug;
};


typedef char MPT_False;


struct MPT_True { int m[2]; };

template <typename w_D, typename w_TD>
struct MPT_Finder
{
    template <typename w_T>
    static MPT_True finder( const w_T *, typename w_T::PtrTargetMarker * );
        
    static MPT_False finder( const w_D *, w_TD * );

};

template <typename w_D, typename w_TD = int >
struct MPT_ContainsMember
{
    struct DerivedClass : w_D
    {
    };

    typedef DerivedClass  * DerivedClassp;

    typedef w_TD  * t_TDp;

    enum {
        value = (
            sizeof( MPT_Finder<w_D,w_TD>::finder( DerivedClassp(), t_TDp() ) )
            == sizeof( MPT_True )
        )
    };
    
};

template <int w_select, typename w_T0, typename w_T1>
struct MPT_Select_Def
{
};

template <typename w_T0, typename w_T1>
struct MPT_Select_Def<0, w_T0, w_T1>
{
    typedef     w_T0    type;
};

template <typename w_T0, typename w_T1>
struct MPT_Select_Def<1, w_T0, w_T1>
{
    typedef     w_T1    type;
};



// ======== MPT_Select ================================================
template <typename w_ValueT, typename w_T0, typename w_T1>
struct MPT_Select
{
    typedef typename MPT_Select_Def<
        w_ValueT::value,
        w_T0,
        w_T1
    >::type                     type;
    
};



}; // namespace

#endif // x_at_pointers_h_x

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