type.h

Go to the documentation of this file.

// Evo C++ Library
/* Copyright 2019 Justin Crowell
Distributed under the BSD 2-Clause License -- see included file LICENSE.txt for details.
*/

#pragma once
#ifndef INCL_evo_type_h
#define INCL_evo_type_h

#include "impl/container.h"

namespace evo {


#define EVO_MIN(A, B) ((B) < (A) ? (B) : (A))

#define EVO_MAX(A, B) ((B) > (A) ? (B) : (A))


template<class T> class SafeBool {
protected:
    typedef void (SafeBool::*SafeBoolType)() const;
    void This_type_does_not_support_this_comparison() const { }
public:
    SafeBool() { }
    SafeBool(const SafeBool&) { }
    operator SafeBoolType() const
        { return (!(static_cast<const T*>(this))->operator!() ? &SafeBool::This_type_does_not_support_this_comparison : 0); }
};

template<typename T, typename U> bool operator==(const SafeBool<T>& l, const SafeBool<U>& r)
    { l.This_type_does_not_support_this_comparison(); return false; }
template<typename T, typename U> bool operator!=(const SafeBool<T>& l, const SafeBool<U>& r)
    { l.This_type_does_not_support_this_comparison(); return false; }
namespace impl {
    struct SafeBoolTestCov : SafeBool<SafeBoolTestCov> {
        void test()
            { This_type_does_not_support_this_comparison(); }
    };
}

template<class T>
class Nullable : public SafeBool<Nullable<T> > {
public:
    typedef void EvoNullableType;   

    Nullable() : value_((T)0), null_(true)
        { }

    Nullable(const Nullable<T>& src) : value_(src.value_), null_(src.null_)
        { }

    Nullable(ValNull) : value_((T)0), null_(true) {
    }

    Nullable(T num) : value_(num), null_(false)
        { }

    Nullable<T>& operator=(const Nullable<T>& src)
        { null_ = src.null_; value_ = src.value_; return *this; }

    Nullable<T>& operator=(T value)
        { null_ = false; value_ = value; return *this; }

    Nullable<T>& operator=(ValNull)
        { null_ = true; value_ = (T)0; return *this; }

    bool operator!() const
        { return (null_ || value_ == (T)0); }

    bool operator==(const Nullable<T>& val) const
        { return (null_ ? val.null_ : !val.null_ && value_ == val.value_); }

    bool operator==(T val) const
        { return (null_ ? false : value_ == val); }

    bool operator!=(const Nullable<T>& val) const
        { return (null_ ? !val.null_ : val.null_ || value_ != val.value_); }

    bool operator!=(T val) const
        { return (null_ ? true : value_ != val); }

    bool operator<(const Nullable<T>& val) const
        { return (null_ ? !val.null_ : value_ < val.value_); }

    bool operator<(T val) const
        { return (null_ ? true : value_ < val); }

    bool operator<=(const Nullable<T>& val) const
        { return (null_ ? true : (val.null_ ? false : value_ <= val.value_)); }

    bool operator<=(T val) const
        { return (null_ ? true : value_ <= val); }

    bool operator>(const Nullable<T>& val) const
        { return (null_ ? false : (val.null_ ? true : value_ > val.value_)); }

    bool operator>(T val) const
        { return (null_ ? false : value_ > val); }

    bool operator>=(const Nullable<T>& val) const
        { return (null_ ? val.null_ : (val.null_ ? true : value_ >= val.value_)); }

    bool operator>=(T val) const
        { return (null_ ? false : value_ >= val); }

    int compare(const Nullable<T>& val) const {
        if (null_) {
            if (val.null_)
                return 0;
            return -1;
        } else if (val.null_)
            return 1;
        return (value_ == val.value_ ? 0 : (value_ < val.value_ ? -1 : 1));
    }

    int compare(T val) const {
        if (null_)
            return -1;
        return (value_ == val ? 0 : (value_ < val ? -1 : 1));
    }

    const T& operator*() const
        { return value_; }

    T& operator*()
        { return value_; }

    bool null() const
        { return null_; }

    bool valid() const
        { return !null_; }

    const T& value() const
        { return value_; }

    T& value()
        { return value_; }

    Nullable<T>& set()
        { null_ = true; value_ = (T)0; return *this; }

    Nullable<T>& set(const Nullable<T>& src)
        { null_ = src.null_; value_ = src.value_; return *this; }

    Nullable<T>& set(T src)
        { null_ = false; value_ = src; return *this; }

    T& denull() {
        if (null_)
            null_ = false;
        return value_;
    }

private:
    T    value_;
    bool null_;
};

// Specialized for minimum size
template<> class Nullable<bool> : public SafeBool<Nullable<bool> > {
public:
    Nullable()
        { value_ = (uchar)nvNULL; }
    Nullable(const Nullable<bool>& src)
        { value_ = src.value_; }
    Nullable(bool val)
        { value_ = (uchar)(val ? nvTRUE : nvFALSE); }
    Nullable<bool>& operator=(const Nullable<bool>& src)
        { value_ = src.value_; return *this; }
    Nullable<bool>& operator=(bool val)
        { value_ = (uchar)(val ? nvTRUE : nvFALSE); return *this; }
    Nullable<bool>& operator=(ValNull)
        { value_ = (uchar)nvNULL; return *this; }

    bool operator!() const
        { return (value_ != (uchar)nvTRUE); }
    bool operator==(const Nullable<bool>& val) const
        { return (value_ == val.value_); }
    bool operator==(bool val) const
        { return (value_ != (uchar)nvNULL && val == (value_ == (uchar)nvTRUE)); }
    bool operator!=(const Nullable<bool>& val) const
        { return (value_ != val.value_); }
    bool operator!=(bool val) const
        { return (value_ == (uchar)nvNULL || val != (value_ == (uchar)nvTRUE)); }

    bool operator<(const Nullable<bool>& val) const
        { return (value_ < val.value_); }
    bool operator<(bool val) const
        { return (value_ < (uchar)(val ? nvTRUE : nvFALSE)); }
    bool operator<=(const Nullable<bool>& val) const
        { return (value_ <= val.value_); }
    bool operator<=(bool val) const
        { return (value_ <= (uchar)(val ? nvTRUE : nvFALSE)); }
    bool operator>(const Nullable<bool>& val) const
        { return (value_ > val.value_); }
    bool operator>(bool val) const
        { return (value_ > (uchar)(val ? nvTRUE : nvFALSE)); }
    bool operator>=(const Nullable<bool>& val) const
        { return (value_ >= val.value_); }
    bool operator>=(bool val) const
        { return (value_ >= (uchar)(val ? nvTRUE : nvFALSE)); }

    int compare(const Nullable<bool>& val) const
        { return (value_ == val.value_ ? 0 : (value_ < val.value_ ? -1 : 1)); }

    const bool operator*() const
        { return (value_ == (uchar)nvTRUE); }

    bool null() const
        { return (value_ == (uchar)nvNULL); }
    bool valid() const
        { return (value_ != (uchar)nvNULL); }
    const bool value() const
        { return (value_ == (uchar)nvTRUE); }

    Nullable<bool>& set()
        { value_ = (uchar)nvNULL; return *this; }
    Nullable<bool>& set(const Nullable<bool>& src)
        { value_ = src.value_; return *this; }
    Nullable<bool>& set(bool val)
        { value_ = (uchar)(val ? nvTRUE : nvFALSE); return *this; }

    bool denull() {
        if (value_ == nvNULL) {
            value_ = nvFALSE;
            return false;
        }
        return (value_ == nvTRUE);
    }

private:
    enum NullableValue {
        nvNULL=0,
        nvFALSE,
        nvTRUE
    };

    uchar value_;
};
template<class T> inline bool operator==(T val1, const Nullable<T>& val2)
    { return val2 == val1; }

template<class T> inline bool operator!=(T val1, const Nullable<T>& val2)
    { return val2 != val1; }

template<class T> inline bool operator<(T val1, const Nullable<T>& val2)
    { return val2 > val1; }

template<class T> inline bool operator<=(T val1, const Nullable<T>& val2)
    { return val2 >= val1; }

template<class T> inline bool operator>(T val1, const Nullable<T>& val2)
    { return val2 < val1; }

template<class T> inline bool operator>=(T val1, const Nullable<T>& val2)
    { return val2 <= val1; }


struct Bool : public Nullable<bool> {
    typedef bool Type;                                  

    static const int BYTES = sizeof(bool);              
    static const int BITS  = 1;                         

    Bool()
        { }

    Bool(const Bool& val) : Nullable<bool>(val)
        { }

    Bool(bool val) : Nullable<bool>(val)
        { }

    Bool& operator=(const Bool& val)
        { Nullable<bool>::operator=(val); return *this; }

    Bool& operator=(bool val)
        { Nullable<bool>::operator=(val); return *this; }

    Bool& operator=(ValNull)
        { Nullable<bool>::set(); return *this; }
};


template<class T>
struct CharT : public Nullable<T> {
    typedef CharT<T> This;          
    typedef T        Type;          

    static const int BYTES = sizeof(T);                
    static const int BITS  = BYTES * CHAR_BIT;         

    enum Category {
        cNONE=0,            
        cSPACE,             
        cSYMBOL,            
        cALPHANUM,          
        cDIGIT,             
        cALPHA,             
        cALPHA_U,           
        cALPHA_L            
    };

    enum Digit {
        dNONE=0,            
        dBASE36,            
        dHEX,               
        dDECIMAL,           
        dOCTAL              
    };

    CharT()
        { }

    CharT(const CharT<T>& val) : Nullable<T>(val)
        { }

    CharT(T val) : Nullable<T>(val)
        { }

    CharT<T>& operator=(const CharT<char>& val)
        { Nullable<T>::operator=(val); return *this; }

    CharT<T>& operator=(char val)
        { Nullable<T>::operator=(val); return *this; }

    CharT<T>& operator=(ValNull)
        { Nullable<T>::set(); return *this; }
};

struct Char : public CharT<char> {
    static Category category(char ch) {
        const char chmap[128] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0,            // 0-15
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,            // 16-31
            1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,            // 32-47
            4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 2, 2, 2, 2,            // 48-63
            2, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,            // 64-79
            6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 2, 2, 2,            // 80-95
            2, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,            // 96-111
            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 2, 2, 2, 2, 0             // 112-127
        };
        return (Category)((uchar)ch < 128 ? chmap[(uint)ch] : 0);
    }

    static Digit digit(char ch) {
        const char chmap[128] = {
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,            // 0-15
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,            // 16-31
            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,            // 32-47
            4, 4, 4, 4, 4, 4, 4, 4, 3, 3, 0, 0, 0, 0, 0, 0,            // 48-63
            0, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,            // 64-79
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0,            // 80-95
            0, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,            // 96-111
            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0             // 112-127
        };
        return (Digit)((uchar)ch < 128 ? chmap[(uint)ch] : 0);
    }

    static bool isspace(char ch)
        { return (ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'); }

    static bool isupper(char ch)
        { return (ch >= 'A' && ch <= 'Z'); }

    static bool islower(char ch)
        { return (ch >= 'a' && ch <= 'z'); }

    static bool isalpha(char ch)
        { return ((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')); }

    static bool isalnum(char ch)
        { return ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')); }

    static bool isdigit(char ch)
        { return (ch >= '0' && ch <= '9'); }

    Char()
        { }

    Char(const Char& val) : CharT<char>(val)
        { }

    Char(char val) : CharT<char>(val)
        { }

    Char& operator=(const Char& val)
        { Nullable<char>::operator=(val); return *this; }

    Char& operator=(char val)
        { Nullable<char>::operator=(val); return *this; }

    Char& operator=(ValNull)
        { Nullable<char>::set(); return *this; }
};


namespace impl {
    template<int IntSize> struct IntMaxLen { };
    // Max string length by int size in bytes, including either sign or hex/oct prefix (0x/0), but not both
    template<> struct IntMaxLen<1> { static const int value = 4; };
    template<> struct IntMaxLen<2> { static const int value = 7; };
    template<> struct IntMaxLen<4> { static const int value = 12; };
    template<> struct IntMaxLen<8> { static const int value = 23; };
}

// Disable constant truncation MSVC warnings for constants using bit manipulation
#if defined(_MSC_VER)
    #pragma warning(push)
    #pragma warning(disable:4309)
#endif

template<class T>
struct IntegerT : public Nullable<T> {
    typedef IntegerT<T> This;       
    typedef T           Type;       

    static const bool SIGN      = IsSigned<T>::value;                   
    static const int  BYTES     = sizeof(T);                            
    static const int  BITS      = sizeof(T) * 8;                        
    static const int  MAXSTRLEN = impl::IntMaxLen<sizeof(T)>::value;    

    static const int  BITS_MINUS_1 = BITS - 1;                          
    static const T    RBIT         = 0x01;                              
    static const T    LBIT         = RBIT << BITS_MINUS_1;              
    static const T    ZERO         = 0;                                 
    static const T    ALLBITS      = T(~ZERO);                          

    static const T    MIN = (SIGN ? LBIT : 0);                          
    static const T    MAX = (SIGN ? ~LBIT : ALLBITS);                   

    static int maxlen(int base=10) {
        // Note: Newer compilers (gcc 4.9.2) give c++11 'narrowing conversion' warnings if 'values' are smaller than int, casting doesn't fix
        if (base >= 100)
            base -= 100;
        assert( base > 1 );
        assert( base <= 36 );
        static const int n = (SIGN ? 1 : 0);
        static const int VALUES[] = {
            digits(MAX,2)+n, digits(MAX,3)+n, digits(MAX,4)+n, digits(MAX,5)+n, digits(MAX,6)+n,
            digits(MAX,7)+n, digits(MAX,8)+1, digits(MAX,9)+n, digits(MAX,10)+n, digits(MAX,11)+n,
            digits(MAX,12)+n, digits(MAX,13)+n, digits(MAX,14)+n, digits(MAX,15)+n, digits(MAX,16)+n+1,
            digits(MAX,17)+n, digits(MAX,18)+n, digits(MAX,19)+n, digits(MAX,20)+n, digits(MAX,21)+n,
            digits(MAX,22)+n, digits(MAX,23)+n, digits(MAX,24)+n, digits(MAX,25)+n, digits(MAX,26)+n,
            digits(MAX,27)+n, digits(MAX,28)+n, digits(MAX,29)+n, digits(MAX,30)+n, digits(MAX,31)+n,
            digits(MAX,32)+n, digits(MAX,33)+n, digits(MAX,34)+n, digits(MAX,35)+n, digits(MAX,36)+n
        };
        return VALUES[base-2];
    }

    static int digits(T num, int base=10) {
        if (base >= 100)
            base -= 100;
        assert( base > 1 );
        assert( base < 100 );
        int result = 0;
        if (num == 0)
            result = 1;
        else {
            if (num < 0)
                ++result;
            while (num != 0) {
                num /= (int8)base;
                ++result; 
            }
        }
        return result;
    }

    IntegerT()
        { }

    IntegerT(const IntegerT<T>& val) : Nullable<T>(val)
        { }

    IntegerT(T val) : Nullable<T>(val)
        { }

    IntegerT<T>& operator=(const IntegerT<T>& val)
        { Nullable<T>::operator=(val); return *this; }

    IntegerT<T>& operator=(T val)
        { Nullable<T>::operator=(val); return *this; }

    IntegerT<T>& operator=(ValNull)
        { Nullable<T>::set(); return *this; }

    using Nullable<T>::value;

    T value(T defval) const
        { return (Nullable<T>::null() ? defval : Nullable<T>::value()); }
};

#if defined(_MSC_VER)
    #pragma warning(pop)
#endif

typedef IntegerT<short> Short;

typedef IntegerT<int> Int;

typedef IntegerT<long> Long;

typedef IntegerT<longl> LongL;

typedef IntegerT<int8> Int8;

typedef IntegerT<int16> Int16;

typedef IntegerT<int32> Int32;

typedef IntegerT<int64> Int64;

typedef IntegerT<ushort> UShort;

typedef IntegerT<uint> UInt;

typedef IntegerT<ulong> ULong;

typedef IntegerT<ulongl> ULongL;

typedef IntegerT<uint8> UInt8;

typedef IntegerT<uint16> UInt16;

typedef IntegerT<uint32> UInt32;

typedef IntegerT<uint64> UInt64;


namespace impl {
    template<class T> struct ConstFloatT {
        static T point1() { return 0.1f; }
        static T ten()    { return 10.0f; }
    };
    template<> struct ConstFloatT<double> {
        static double point1() { return 0.1; }
        static double ten()    { return 10.0; }
    };
    template<> struct ConstFloatT<ldouble> {
        static ldouble point1() { return 0.1L; }
        static ldouble ten()    { return 10.0L; }
    };
};

template<class T>
struct FloatT : public Nullable<T> {
    typedef FloatT<T> This;         
    typedef T         Type;         

    static const bool IS        = IsFloat<T>::value;                        
    static const bool SIGN      = true;                                     
    static const int  BYTES     = sizeof(T);                                
    static const int  MAXDIGITS = std::numeric_limits<T>::digits10;         
    static const bool NANOK     = std::numeric_limits<T>::has_quiet_NaN;    

    static const int MAXDIGITS_AUTO = MAXDIGITS + 15;       

    static int maxdigits_prec(int exp, int precision) {
        const int BASEDIGITS = MAXDIGITS + 9;
        return BASEDIGITS + (exp < 0 ? -exp : exp) + precision;
    }

    static T precision() {
        static const T VAL = evo_pow(impl::ConstFloatT<T>::point1(), std::numeric_limits<T>::digits10);
        return VAL;
    }

    static T min()
        { return std::numeric_limits<T>::min(); }

    static int minexp()
        { return std::numeric_limits<T>::min_exponent10; }

    static T max()
        { return std::numeric_limits<T>::max(); }

    static int maxexp()
        { return std::numeric_limits<T>::max_exponent10; }

    static T inf()
        { return std::numeric_limits<T>::infinity(); }

    static bool inf(T num) {
        if (num < 0.0)
            num = -num;
        return (std::numeric_limits<T>::has_infinity && num == std::numeric_limits<T>::infinity());
    }

    static bool nan(T num)
        { return (num != num); }

    static T nan() {
        static const T val = (T)(NANOK ? std::numeric_limits<T>::quiet_NaN() : 0.0);
        return val;
    }

    static T eps()
        { return std::numeric_limits<T>::epsilon(); }

    static bool eq(T val1, T val2) {
        static const T EPSILON = std::numeric_limits<T>::epsilon();
        return ( (nan(val1) && nan(val2)) || val1 == val2 || evo_fabs(val1 - val2) <= EPSILON );
    }

    static bool eq(T val1, T val2, T eps)
        { return ( (nan(val1) && nan(val2)) || val1 == val2 || evo_fabs(val1 - val2) <= eps ); }

    static T exp10(T num, int exp) {
        T result = 0.0;
        if (exp == 0)
            result = num;
        else if (num != 0.0) {
            bool neg = false;
            if (exp < 0) {
                neg = true;
                exp = -exp;
            }
            T power = 10.0;
            result = 1.0;
            for (int bit = 1; exp != 0; bit <<= 1) {
                if (exp & bit) {
                    exp ^= bit;
                    result *= power;
                    if (exp == 0)
                        break;
                }
                power *= power;
            }
            result = (neg ? num / result : num * result);
        }
        return result;
    }

    static T fexp10(int& exp, T num) {
        bool neg = false;
        if (num < 0.0)
            { neg = true; num = -num; }
        exp = 0;
        if (!nan(num) && !inf(num) && num != 0.0) {
            if (num >= 1.0) {
                static const int BIGNUM_DIGITS = std::numeric_limits<T>::digits10;
                static const T   BIGNUM        = evo_pow(impl::ConstFloatT<T>::ten(), BIGNUM_DIGITS);
                while (num >= BIGNUM)
                    { num /= BIGNUM;  exp += BIGNUM_DIGITS; }
                while (num >= 1000.0)
                    { num /= 1000.0;  exp += 3; }
                do {
                    num /= 10.0;  ++exp;
                } while (num >= 1.0);
            } else {
                while (num < 0.001 && num > 0.0)
                    { num *= 1000.0;  exp -= 3; }
                if (num > 0.0) {
                    if (num < 0.01)
                        { num *= 100.0;  exp -= 2; }
                    else if (num < 0.1)
                        { num *= 10.0; --exp; }
                }
            }
        }
        return (neg ? -num : num);
    }

    FloatT()
        { }

    FloatT(const FloatT<T>& val) : Nullable<T>(val)
        { }

    FloatT(T val) : Nullable<T>(val)
        { }

    FloatT<T>& operator=(const FloatT<T>& val)
        { Nullable<T>::operator=(val); return *this; }

    FloatT<T>& operator=(T val)
        { Nullable<T>::operator=(val); return *this; }

    FloatT<T>& operator=(ValNull)
        { Nullable<T>::set(); return *this; }

    bool eq1(const Nullable<T>& val) {
        return ( (this->null() && val.null()) ||
                 (this->null() == val.null() && FloatT<T>::eq(this->value(), val.value())) );
    }

    bool eq1(T val)
        { return (!this->null() && FloatT<T>::eq(this->value(), val)); }

    using Nullable<T>::value;

    T value(T defval) const
        { return (Nullable<T>::null() ? defval : Nullable<T>::value()); }
};

typedef FloatT<float> Float;

typedef FloatT<double> FloatD;

typedef FloatT<long double> FloatL;


template<class T, class P=T*>
struct PtrBase : public SafeBool<PtrBase<T> > {
    typedef void EvoNullableType;   
    typedef PtrBase<T,P> Base;      

    P ptr_;            

    const T& operator*() const {
        assert(ptr_ != NULL);
        return *ptr_;
    }

    T& operator*() {
        assert(ptr_ != NULL);
        return *ptr_;
    }

    const T* operator->() const {
        assert(ptr_ != NULL);
        return ptr_;
    }

    T* operator->() {
        assert(ptr_ != NULL);
        return ptr_;
    }

    const T& operator[](ulong index) const {
        assert(ptr_ != NULL);
        return ptr_[index];
    }

    T& operator[](ulong index) {
        assert(ptr_ != NULL);
        return ptr_[index];
    }

    bool operator!() const
        { return ptr_ == NULL; }

    bool operator==(const Base& ptr) const
        { return ptr_ == ptr.ptr_; }

    bool operator==(void* ptr) const
        { return ptr_ == ptr; }

    bool operator!=(const Base& ptr) const
        { return ptr_ != ptr.ptr_; }

    bool operator!=(void* ptr) const
        { return ptr_ != ptr; }

    bool operator<(const Base& ptr) const
        { return ptr_ < ptr.ptr_; }

    bool operator<(void* ptr) const
        { return ptr_ < ptr; }

    bool operator<=(const Base& ptr) const
        { return ptr_ <= ptr.ptr_; }

    bool operator<=(void* ptr) const
        { return ptr_ <= ptr; }

    bool operator>(const Base& ptr) const
        { return ptr_ > ptr.ptr_; }

    bool operator>(void* ptr) const
        { return ptr_ > ptr; }

    bool operator>=(const Base& ptr) const
        { return ptr_ >= ptr.ptr_; }

    bool operator>=(void* ptr) const
        { return ptr_ >= ptr; }

    bool null() const
        { return (ptr_ == NULL); }

    bool valid() const
        { return (ptr_ != NULL); }

    const T* ptr() const
        { return ptr_; }

    T* ptr()
        { return ptr_; }
};


template<class T, class C> struct Convert {
    static void set(C& dest, T value)
        STATIC_ASSERT_FUNC_UNUSED               // Override required to support conversion

    static void add(C& dest, T value)
        STATIC_ASSERT_FUNC_UNUSED               // Override required to support conversion

    static bool addq(C& dest, T value, typename C::Value delim)
        STATIC_ASSERT_FUNC_UNUSED_RET(false)    // Override required to support conversion

    
    static const T& value(const T& src)
        STATIC_ASSERT_FUNC_UNUSED_RET(src)      // Override required to support conversion
};


// Special type for NONE, ALL, END values -- used internally.
struct EndT {
    // Evo sizes are unsigned, use max value
    operator unsigned char() const
        { return IntegerT<unsigned char>::MAX; }
    operator unsigned short() const
        { return IntegerT<unsigned short>::MAX; }
    operator unsigned int() const
        { return IntegerT<unsigned int>::MAX; }
    operator unsigned long() const
        { return IntegerT<unsigned long>::MAX; }
    operator unsigned long long() const
        { return IntegerT<unsigned long long>::MAX; }

    EndT() { }
};

template<class T> bool operator==(T a, EndT)
    { return (a == IntegerT<T>::MAX); }
template<class T> bool operator==(EndT, T b)
    { return (b == IntegerT<T>::MAX); }

template<class T> bool operator!=(T a, EndT)
    { return (a != IntegerT<T>::MAX); }
template<class T> bool operator!=(EndT, T b)
    { return (b != IntegerT<T>::MAX); }
static const EndT NONE;

static const EndT ALL;

static const EndT END;


#define EVO_PDEFAULT ((T*)IntegerT<std::size_t>::MAX)

#define EVO_PEMPTY ((T*)1)

#define EVO_PPEMPTY ((T**)1)


// Implementation
namespace impl {
    template<class T, int SZ=sizeof(T)>
    struct NextPow2 {
        static T next(T v) {
            T n = 1;
            while (n < v)
                n <<= 1;
            return n;
        }
    };

    template<class T> struct NextPow2<T,1> {
        static uint8 next(uint8 v) {
            --v;
            v |= v >> 1;
            v |= v >> 2;
            v |= v >> 4;
            return ++v;
        }
    };
    template<class T> struct NextPow2<T,2> {
        static uint16 next(uint16 v) {
            --v;
            v |= v >> 1;
            v |= v >> 2;
            v |= v >> 4;
            v |= v >> 8;
            return ++v;
        }
    };
    template<class T> struct NextPow2<T,4> {
        static uint32 next(uint32 v) {
            --v;
            v |= v >> 1;
            v |= v >> 2;
            v |= v >> 4;
            v |= v >> 8;
            v |= v >> 16;
            return ++v;
        }
    };
    template<class T> struct NextPow2<T,8> {
        static uint64 next(uint64 v) {
            --v;
            v |= v >> 1;
            v |= v >> 2;
            v |= v >> 4;
            v |= v >> 8;
            v |= v >> 16;
            v |= v >> 32;
            return ++v;
        }
    };
}
template<class T>
inline T next_pow2(T v) {
    assert( !IntegerT<T>::SIGN );
    v += (v == 0);
    return impl::NextPow2<T>::next(v);
}

template<class Size>
inline Size size_pow2(Size size, Size minsize=2) {
    assert( !IntegerT<Size>::SIGN );
    if (size <= minsize)
        return minsize;
    const Size MAX_SIZE = (std::numeric_limits<Size>::max() >> 1) + 1;
    if (size >= MAX_SIZE)
        return MAX_SIZE;
    return impl::NextPow2<Size>::next(size);
}

template<class T>
inline bool is_pow2(T num)
    { return (num && (num & (num - 1)) == 0); }


class PureBase {
public:
    virtual ~PureBase() {
    }
};


}
#endif