base_types.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_TYPES_HH
#define BASE_TYPES_HH 1

#include "base_thread_types.hh"

// base module is gfxsys-independent except for typedef GLfloat fp.
#include "gfx_gfxsys.hh"

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

// Basic types.
//
#if ! BASE_OMIT_BOOL
typedef unsigned char      Bool;  
#endif
typedef unsigned char      uchar;
typedef unsigned int       uint;
//typedef unsigned long    ulong;  // troublesome, so is #define ulong
#if GFXSYS_OPENGL
typedef GLfloat            fp;  // dependency: OpenGL code casts fp as GLfloat
#else
typedef float              fp;
#endif
#if SPEED
typedef fp                 fpx;  // extended-precision float
#else
typedef double             fpx;
#endif

//------------------------------------------------------------------------------

namespace base {

// Exact-size types (limited use).
// int64() cast or "LL" suffix is critical to compile 64-bit shifts correctly.
#if ! NO_STDINT
typedef int8_t             int8;
typedef uint8_t            uint8;
typedef int16_t            int16;
typedef uint16_t           uint16;
typedef int32_t            int32;
typedef uint32_t           uint32;
typedef int64_t            int64;   // C99
typedef uint64_t           uint64;  // C99
#else
typedef char               int8;
typedef unsigned char      uint8;
typedef short              int16;
typedef unsigned short     uint16;
typedef int                int32;
typedef unsigned int       uint32;
typedef long long          int64;   // C99
typedef unsigned long long uint64;  // C99
#endif

// Limited use: may result in unportable code.
// FYI, on Linux x86-64, int is 32-bits, long is 64-bits.
//
const uint INT_BITS  = sizeof(int)   * 8;
const uint LONG_BITS = sizeof(long)  * 8;
const uint PTR_BITS  = sizeof(void*) * 8;

class Void { };

#define DECLARE_DISTINCT_TYPE( CLASS, T )                                                   \
class CLASS                                                                                 \
{                                                                                           \
public:                                                                                     \
                CLASS( void ) : mVal(0) { }  /* clients depends on zero */                  \
                CLASS( T val ) : mVal(val) { }                                              \
                operator T() const { return mVal; }                                         \
    CLASS&      operator=( const T& val ) { mVal = val; return *this; }                     \
    friend bool operator==( const CLASS& a, const CLASS& b ) { return a.mVal == b.mVal; }   \
    friend bool operator!=( const CLASS& a, const CLASS& b ) { return a.mVal != b.mVal; }   \
                /* Arithmetic operators are omitted because of ambiguity. */                \
                /* Rather, cast to fundamental type then do the math. */                    \
private:                                                                                    \
    T   mVal;                                                                               \
};

// Fundamental types auto-initialized zero.
DECLARE_DISTINCT_TYPE( bool0, bool )
DECLARE_DISTINCT_TYPE( int0,  int  )
DECLARE_DISTINCT_TYPE( uint0, uint )

class Bits
{
public:
    Bits( uint bits = 0 ) : mBits(bits) { }
    bool    Get( uint idx ) const     { ASSERT(idx < BIT_CNT); return mBits & (1<<idx); }  // get bit (true or false)
    void    Set( uint idx )           { ASSERT(idx < BIT_CNT); mBits |= (1<<idx); }        // turn on bit
    void    Set( uint idx, bool set ) { if ( set ) Set(idx); else Clear(idx); }            // turn on/off bit
    void    Clear( uint idx )         { ASSERT(idx < BIT_CNT); mBits &= ~(1<<idx); }       // turn off bit
    Bits&   operator=( uint bits )    { mBits = bits; return *this; }  // assign from uint
            operator uint() const     { return mBits; }                // convert to uint
private:
    uint                mBits;
    CLASS_CONST uint    BIT_CNT = 32;
};

struct Seconds
{
    typedef int64 Int;
    Seconds( void )     : mSeconds(0) { }
    Seconds( Int secs ) : mSeconds(secs) { }
    operator Int() const { return mSeconds; }
    friend inline Seconds operator+( const Seconds& a, const Seconds& b ) { return a.mSeconds + b.mSeconds; }
    friend inline Seconds operator-( const Seconds& a, const Seconds& b ) { return a.mSeconds - b.mSeconds; }
private:
    Int mSeconds;
};

struct Milliseconds
{
    typedef int64 Int;
    Milliseconds( void )          : mMilliseconds(0) { }
    Milliseconds( Int millisecs ) : mMilliseconds(millisecs) { }
    Milliseconds( Seconds secs )  : mMilliseconds(Int(secs)*Int(THOUSAND)) { }
    operator Int() const { return mMilliseconds; }
    friend inline Milliseconds operator+( const Milliseconds& a, const Milliseconds& b ) { return a.mMilliseconds + b.mMilliseconds; }
    friend inline Milliseconds operator-( const Milliseconds& a, const Milliseconds& b ) { return a.mMilliseconds - b.mMilliseconds; }
    friend inline Milliseconds operator*( const Milliseconds& a, const Milliseconds& b ) { return a.mMilliseconds * b.mMilliseconds; }
    friend inline Milliseconds operator/( const Milliseconds& a, const Milliseconds& b ) { return a.mMilliseconds / b.mMilliseconds; }
    friend inline         bool operator<(  const Milliseconds& a, const Milliseconds& b ) { return a.mMilliseconds <  b.mMilliseconds; }
    friend inline         bool operator<=( const Milliseconds& a, const Milliseconds& b ) { return a.mMilliseconds <= b.mMilliseconds; }
    friend inline         bool operator>(  const Milliseconds& a, const Milliseconds& b ) { return a.mMilliseconds >  b.mMilliseconds; }
    friend inline         bool operator>=( const Milliseconds& a, const Milliseconds& b ) { return a.mMilliseconds >= b.mMilliseconds; }
    Milliseconds& operator+=( const Milliseconds& src ) { mMilliseconds += src.mMilliseconds; return *this; }
    Milliseconds& operator-=( const Milliseconds& src ) { mMilliseconds -= src.mMilliseconds; return *this; }
private:
    Int mMilliseconds;
};

struct Microseconds
{
    typedef int64 Int;
    Microseconds( void )                   : mMicroseconds(0) { }
    Microseconds( Int usecs )              : mMicroseconds(usecs) { }
    Microseconds( Milliseconds millisecs ) : mMicroseconds(Int(millisecs)*Int(THOUSAND)) { }
    Microseconds( Seconds secs )           : mMicroseconds(Int(secs)*Int(MILLION)) { }
    operator Int() const { return mMicroseconds; }
private:
    Int mMicroseconds;
};

#undef virtual

} // namespace base

#endif // BASE_TYPES_HH

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:07 2007