ptypes.h

使用stl技术,(还没看,是听说的)

class ptpublic strmap: protected strlist 
{
protected:
    unknown* getobj(const string& key) const;
    unknown* getobj(const char* key) const;
    void putobj(const string& key, unknown* obj);

public:
    strmap();
    strmap(slflags iflags);
    virtual ~strmap();

    ptpublic friend int      length(const strmap& s);
    ptpublic friend void     clear(strmap& m);
    ptpublic friend void     put(strmap& m, const string& key, unknown* obj);
    ptpublic friend unknown* get(const strmap& m, const string& key);
    ptpublic friend void     del(strmap& m, const string& key);

    unknown* operator[] (const string& key);
};


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


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)
        { unknown* t = obj; PTYPES_NAMESPACE::put(m, str, t); }

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


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

// undocumented

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();

    ptpublic friend int   length(const textmap& m);
    ptpublic friend void  clear(textmap& m);
    ptpublic friend const string& get(const textmap& m, const string& name);
    ptpublic friend void  put(textmap& m, const string& name, const string& value);
    ptpublic friend void  del(textmap& m, const string& name);

    const string& operator[] (const string& name);
};


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


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


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

    VAR_COMPOUND = VAR_STRING
};


class ptpublic variant
{
    friend class string;
    friend class _varray;

protected:
    int tag;            // VAR_XXX
    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&);
    ptpublic friend int  vartype(const variant& v);
    ptpublic friend bool isnull(const variant& v);
    ptpublic friend bool isint(const variant& v);
    ptpublic friend bool isbool(const variant& v);
    ptpublic friend bool isfloat(const variant& v);
    ptpublic friend bool isstring(const variant& v);
    ptpublic friend bool isarray(const variant& v);
    ptpublic friend bool isobject(const variant& v);
    ptpublic friend bool iscompound(const variant& v);

    // 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 bool anext(const variant& a, int&, variant& item, string& key);
    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!
    ptpublic friend void initialize(variant& v);
    ptpublic friend void initialize(variant& v, large i);
    ptpublic friend void initialize(variant& v, int i);
    ptpublic friend void initialize(variant& v, unsigned int i);
    ptpublic friend void initialize(variant& v, bool i);
    ptpublic friend void initialize(variant& v, double i);
    ptpublic friend void initialize(variant& v, const char* i);
    ptpublic friend void initialize(variant& v, const string& i);
    ptpublic friend void initialize(variant& v, component* i);
    ptpublic friend void initialize(variant& v, const variant& i);
    ptpublic friend void finalize(variant& v);
};


typedef variant* pvariant;


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

inline void initialize(variant& v)                   { v.initialize(); }
inline void initialize(variant& v, large i)          { v.initialize(i); }
inline void initialize(variant& v, int i)            { v.initialize(large(i)); }
inline void initialize(variant& v, unsigned int i)   { v.initialize(large(i)); }
inline void initialize(variant& v, bool i)           { v.initialize(i); }
inline void initialize(variant& v, double i)         { v.initialize(i); }
inline void initialize(variant& v, const char* i)    { v.initialize(i); }
inline void initialize(variant& v, const string& i)  { v.initialize(i); }
inline void initialize(variant& v, component* i)     { v.initialize(i); }
inline void initialize(variant& v, const variant& i) { v.initialize(i); }
inline void finalize(variant& v)                     { if (v.tag >= VAR_COMPOUND) v.finalize(); }


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;

    ptpublic friend void clear(_varray& v);
    ptpublic friend int length(_varray& v);

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);
    ptpublic friend bool anext(const variant& a, int&, variant& item, string& key);
};


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



#ifdef _MSC_VER
#pragma pack(pop)
#endif


PTYPES_END

#endif // __PTYPES_H__