ptypes.h

PTypes (C++ Portable Types Library) is a simple alternative to the STL that includes multithreading

// -------------------------------------------------------------------- //
// ---  string map ---------------------------------------------------- //
// -------------------------------------------------------------------- //


class ptpublic strmap: protected strlist 
{
protected:
    unknown* getobj(const string& istr) const;
    unknown* getobj(const char* istr) const;
    void putobj(const string& istr, unknown* iobj);
public:
    strmap();
    strmap(slflags iflags);
    virtual ~strmap();

    unknown* operator[] (const string& istr)    { return getobj(istr); }
    friend inline int length(const strmap& s)   { return s.getcount(); }
    friend inline void clear(strmap& m)         { m.clear(); }
    friend inline unknown* get(const strmap& m, 
        const string& istr)                     { return m.getobj(istr); }
    friend inline void put(strmap& m, 
        const string& istr, unknown* iobj)      { m.putobj(istr, iobj); }
    friend inline void del(strmap& m, 
        const string& istr)                     { m.putobj(istr, nil); }
};


template <class T> class tstrmap: public strmap
{
public:
    tstrmap(): strmap()  {}
    tstrmap(slflags iflags): strmap(iflags)  {}

    friend inline T* get(const tstrmap& m, const string& str)
        { return (T*)PTYPES_NAMESPACE::get((const strmap&)m, str); }

    friend inline void put(tstrmap& m, const string& str, T* obj)
        { PTYPES_NAMESPACE::put(m, str, (unknown*)obj); }

    T* operator[] (const string& str)
        { return (T*)PTYPES_NAMESPACE::get(*this, str); }
};


// -------------------------------------------------------------------- //
// ---  text map ------------------------------------------------------ //
// -------------------------------------------------------------------- //


class ptpublic textmap: protected strlist 
{
protected:
    const string& getvalue(const string& name) const;
    const string& getvalue(const char* name) const;
    void putvalue(const string& name, const string& value);
    void delitem(int i);
    void clear();
public:
    textmap();
    virtual ~textmap();

    const string& operator[] (const string& name)   { return getvalue(name); }
    friend inline int length(const textmap& m)      { return m.getcount(); }
    friend inline void clear(textmap& m)            { m.clear(); }
    friend inline const string& get(const textmap& m, 
        const string& name)                         { return m.getvalue(name); }
    friend inline void put(textmap& m, 
        const string& name, const string& value)    { m.putvalue(name, value); }
    friend inline void del(textmap& m, 
        const string& name)                         { m.putvalue(name, nullstring); }
};


// -------------------------------------------------------------------- //
// ---  variant class ------------------------------------------------- //
// -------------------------------------------------------------------- //


enum {
    VAR_NULL,
    VAR_INT,
    VAR_BOOL,
    VAR_FLOAT,
    VAR_STRING,
    VAR_ARRAY,
    VAR_OBJECT,

    VAR_COMPOUND = VAR_STRING
};


class ptpublic variant
{
protected:
    friend class _varray;
    friend class ox::ox_machine;

    int tag;            // VAR_XXX
    union {             // all types of values occupy the same space in the union
        large      i;   // 64-bit int value
        bool       b;   // bool value
        double     f;   // double value
        char*      s;   // string object; can't declare as string because of the union
        _varray*   a;   // pointer to a reference-counted strlist object
        component* o;   // pointer to a reference-counted component object (or derivative)
    } value;            // we need this name to be able to copy the entire union in some situations

    void initialize()                       { tag = VAR_NULL; }
    void initialize(large v)                { tag = VAR_INT; value.i = v; }
    void initialize(bool v)                 { tag = VAR_BOOL; value.b = v; }
    void initialize(double v)               { tag = VAR_FLOAT; value.f = v; }
    void initialize(const char* v)          { tag = VAR_STRING; PTYPES_NAMESPACE::initialize(PTR_TO_STRING(value.s), v); }
    void initialize(const string& v)        { tag = VAR_STRING; PTYPES_NAMESPACE::initialize(PTR_TO_STRING(value.s), v); }
    void initialize(_varray* a);
    void initialize(component* o);
    void initialize(const variant& v);
    void finalize();

    void assign(large);
    void assign(bool);
    void assign(double);
    void assign(const char*);
    void assign(const string&);
    void assign(_varray*);
    void assign(component*);
    void assign(const variant&);

    bool equal(const variant& v) const;

    variant(_varray* a)                     { initialize(a); }

public:
    // construction
    variant()                               { initialize(); }
    variant(int v)                          { initialize(large(v)); }
    variant(unsigned int v)                 { initialize(large(v)); }
    variant(large v)                        { initialize(v); }
    variant(bool v)                         { initialize(v); }
    variant(double v)                       { initialize(v); }
    variant(const char* v)                  { initialize(v); }
    variant(const string& v)                { initialize(v); }
    variant(component* v)                   { initialize(v); }
    variant(const variant& v)               { initialize(v); }
    ~variant()                              { finalize(); }

    // assignment
    variant& operator= (int v)              { assign(large(v)); return *this; }
    variant& operator= (unsigned int v)     { assign(large(v)); return *this; }
    variant& operator= (large v)            { assign(v); return *this; }
    variant& operator= (bool v)             { assign(v); return *this; }
    variant& operator= (double v)           { assign(v); return *this; }
    variant& operator= (const char* v)      { assign(v); return *this; }
    variant& operator= (const string& v)    { assign(v); return *this; }
    variant& operator= (component* v)       { assign(v); return *this; }
    variant& operator= (const variant& v)   { assign(v); return *this; }

    // typecast
    operator int() const;
    operator unsigned int() const;
    operator long() const;
    operator unsigned long() const;
    operator large() const;
    operator bool() const;
    operator double() const;
    operator string() const;
    operator component*() const;

    // comparison
    bool operator== (const variant& v) const  { return equal(v); }
    bool operator!= (const variant& v) const  { return !equal(v); }

    // typification
    ptpublic friend void clear(variant&);
    friend inline int  vartype(const variant& v)   { return v.tag; }
    friend inline bool isnull(const variant& v)    { return v.tag == VAR_NULL; }
    friend inline bool isint(const variant& v)     { return v.tag == VAR_INT; }
    friend inline bool isbool(const variant& v)    { return v.tag == VAR_BOOL; }
    friend inline bool isfloat(const variant& v)   { return v.tag == VAR_FLOAT; }
    friend inline bool isstring(const variant& v)  { return v.tag == VAR_STRING; }
    friend inline bool isarray(const variant& v)   { return v.tag == VAR_ARRAY; }
    friend inline bool isobject(const variant& v)  { return v.tag == VAR_OBJECT; }
    friend inline bool iscompound(const variant& v){ return v.tag >= VAR_COMPOUND; }

    // array manipulation
    ptpublic friend void aclear(variant&);
    ptpublic friend variant aclone(const variant&);
    ptpublic friend const variant& get(const variant&, const string& key);
    ptpublic friend const variant& get(const variant&, large key);
    ptpublic friend void put(variant&, const string& key, const variant& item);
    ptpublic friend void put(variant&, large key, const variant& item);
    ptpublic friend void del(variant&, const string& key);
    ptpublic friend void del(variant&, large key);

    // keyless arrays (experimental)
    ptpublic friend int  alength(const variant&);
    ptpublic friend bool anext(const variant& a, int&, variant& item);
    ptpublic friend int  aadd(variant&, const variant& item);
    ptpublic friend void aput(variant&, int index, const variant& item);
    ptpublic friend void ains(variant&, int index, const variant& item);
    ptpublic friend void adel(variant&, int index);
    ptpublic friend const variant& aget(const variant&, int index);
    ptpublic friend string akey(const variant&, int index);

    const variant& operator[](const char* key) const    { return get(*this, string(key)); }
    const variant& operator[](const string& key) const  { return get(*this, key); }
    const variant& operator[](large key) const          { return get(*this, key); }

    // 'manual' initialization/finalization, undocumented. use with care!
    friend inline void initialize(variant& v)                   { v.initialize(); }
    friend inline void initialize(variant& v, large i)          { v.initialize(i); }
    friend inline void initialize(variant& v, int i)            { v.initialize(large(i)); }
    friend inline void initialize(variant& v, unsigned int i)   { v.initialize(large(i)); }
    friend inline void initialize(variant& v, bool i)           { v.initialize(i); }
    friend inline void initialize(variant& v, double i)         { v.initialize(i); }
    friend inline void initialize(variant& v, const char* i)    { v.initialize(i); }
    friend inline void initialize(variant& v, const string& i)  { v.initialize(i); }
    friend inline void initialize(variant& v, component* i)     { v.initialize(i); }
    friend inline void initialize(variant& v, const variant& i) { v.initialize(i); }
    friend inline void finalize(variant& v)                     { if (v.tag >= VAR_COMPOUND) v.finalize(); }
};

typedef variant* pvariant;


ptpublic extern const variant nullvar;


//
// variant exception class
//


class ptpublic evariant: public exceptobj
{
protected:
public:
    evariant(const char* msg): exceptobj(msg)  {}
    evariant(const string& msg): exceptobj(msg)  {}
    virtual ~evariant();
};


//
// internal class, used as a variant array element
//


class ptpublic varobject: public unknown
{
public:
    variant var;
    varobject()                   : var()   {}
    varobject(const variant& v)   : var(v)  {}
    virtual ~varobject();
};

typedef varobject* pvarobject;


//
// internal variant array class
//


class ptpublic _varray: protected strlist
{
protected:
    friend class variant;

    int refcount;

    friend inline void clear(_varray& v)   { v.clear(); }
    friend inline int length(_varray& v)   { return v.count; }

public:
    _varray();
    _varray(const _varray&);
    virtual ~_varray();

    const variant& getvar(const string&) const;
    const variant& getvar(int index) const;
    string getkey(int index) const;
    void putvar(const string&, const variant&);
    void putvar(int index, const variant&);
    void insvar(int index, const variant&);
    int addvar(const variant&);
    void delvar(const string&);
    void delvar(int index);
    ptpublic friend bool anext(const variant& a, int&, variant& item);
};


#ifdef _MSC_VER
#pragma pack(pop)
#endif


PTYPES_END

#endif // __PTYPES_H__