src_base_types2.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2004 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#ifndef BASE_TYPES2_HH
#define BASE_TYPES2_HH 1

#include "base/shared_ptr.hh"

namespace base {

//==============================================================================
//==============================================================================
//                     Virtual methods allowed in this section
//==============================================================================
//==============================================================================

template<typename T>
class AbstractIterator
{
public:
                    AbstractIterator( void ) { }
    virtual         ~AbstractIterator() { }

    virtual         operator bool() = 0;
    virtual T       Next( void ) = 0;
};

//==============================================================================
//==============================================================================
//                    Virtual methods forbidden in this section
//==============================================================================
//==============================================================================

// Basic types must be fast, prevent them having virtual functions.
#define virtual VIRTUAL_METHODS_IN_BASIC_TYPES_IS_TOO_SLOW

template<typename T,typename CONTAINER>
class STLIterator : public base::AbstractIterator<T>
{
public:
    explicit    STLIterator( CONTAINER& cont ) : mCont(cont), mIter(cont.begin()) { }
                operator bool() { return mIter != mCont.end(); }
    T           Next( void ) { return *mIter++; }
private:
    CONTAINER&                      mCont;
    typename CONTAINER::iterator    mIter;
};

template<typename T=int>
class Multivar
{
public:
    Multivar( void ) { }
    ~Multivar() { }

    void
    Clear( void )
    {
        mValues.clear();
    }

    void
    Remove( T value )
    {
        mValues.remove( value );
    }

    void
    Set( T value )
    {
        mValues.clear();
        mValues.push_back( value );
    }

    void
    Add( T value )
    {
        // Add value unless present.
        if ( ! Query(value) )
            mValues.push_back( value );
    }

    void
    Toggle( T value )
    {
        if ( Query(value) )
            Remove( value );
        else
            Add( value );
    }

    bool
    Query( T value ) const
    {
        return std::find( mValues.begin(), mValues.end(), value ) != mValues.end();
    }

    bool
    IfEmpty( void ) const
    {
        return mValues.empty();
    }

private:
    std::list<T> mValues;  // multiple values of same type
};

class Percent
{
public:
            Percent( void ) : mPercent(0) { }
            Percent( uint percent ) { Set( percent ); }  // not explicit

    // Assigning an out-of-range percent is an error.
    void    operator=( uint percent ) { Set( percent ); }
            operator uint() const { ASSERT( mPercent <= 100 ); return mPercent; }

    // These clamp.
    void    operator+=( int n ) { SetClamp( int(mPercent) + int(n) ); }
    void    operator-=( int n ) { SetClamp( int(mPercent) - int(n) ); }

private:
    // Set() is strict: it will fail if percent is out-of-range.
    void    Set( uint percent )
            {
                ASSERT( percent <= 100 );
                mPercent = percent;
            }

    // SetClamp() is lenient: it will clamp out-of-range values.
    void    SetClamp( int percent )
            {
                if ( percent < 0 )
                    mPercent = 0;
                else if ( percent > 100 )
                    mPercent = 100;
                else
                    mPercent = uint(percent);
            }
private:
    uint    mPercent;
};

class StringBuf
{
public:
                    StringBuf( void ) { }
                    ~StringBuf() { }
    void            Set( const char* buf )           { mBuf.assign( buf ); }
    void            Set( const char* buf, int len )  { mBuf.assign( buf, len ); }
    void            Set( const uchar* buf, int len ) { mBuf.assign( reinterpret_cast<const char*>(buf), len ); }
    void            Erase( void )               { mBuf.erase(); }
    bool            IfEmpty( void ) const       { return mBuf.size() == 0; }
    int             Size( void ) const          { return mBuf.size(); }
    const string*   GetString( void ) const     { return &mBuf; }
    const char*     GetChars( void ) const      { return mBuf.c_str(); }
    const uchar*    GetUchars( void ) const     { return reinterpret_cast<const uchar*>(mBuf.c_str()); }

public:
    string      mBuf;   
};

class AutoFlag
{
public:
    AutoFlag( SafePtr<bool> pFlag ) : mFlag(pFlag) { *pFlag = true; }
    ~AutoFlag( void ) { *mFlag = false; }
private:
    const SafePtr<bool> mFlag;  
};

#undef virtual

} // namespace base

#endif // BASE_TYPES2_HH

Palomino Flight Simulator documents generated by doxygen 1.5.6 on Mon Dec 29 17:26:59 2008