struct CCL::Variant

#include <variant.h>

struct Variant
{
    // enums

    enum Types;

    // fields

    short type;
    int64 lValue;
    double fValue;
    IString* string;
    IUnknown* object;

    // construction

    Variant ();
    Variant (tresult v);
    Variant (int64 v);
    Variant (uint64 v);
    Variant (int v);
    Variant (uint32 v);
    Variant (int16 v);
    Variant (uint16 v);
    Variant (int8 v);
    Variant (uint8 v);
    Variant (bool b, int flags = 0);
    Variant (double v);
    Variant (float v);
    Variant (const char* s);
    Variant (StringRef s, bool shared = false);
    Variant (const IUnknown* o, bool shared = false);
    Variant (const Variant& v);

    template  <class T>
    Variant (const UnknownPtr <T>& p);

    template  <class T>
    Variant (const AutoPtr <T>& p);

    template  <class T>
    Variant (const SharedPtr <T>& p);

    // methods

    short getType () const;
    bool isValid () const;
    bool isInt () const;
    bool isFloat () const;
    bool isNumeric () const;
    bool isString () const;
    bool isObject () const;
    bool isNil () const;
    bool isShared () const;
    bool isBoolFormat () const;
    void setBoolFormat (bool state = true);
    short getUserFlags () const;
    void setUserFlags (short flags);
    short getUserValue () const;
    void setUserValue (short value);
    void clear ();
    void share ();
    bool toString (String& string) const;
    String toString () const;
    Variant& fromString (StringRef string);
    bool toCString (MutableCString& string, TextEncoding encoding = Text::kASCII) const;
    int64 parseLargeInt () const;
    int64 parseLargeInt (int64 errorValue) const;
    int parseInt () const;
    int parseInt (int errorValue) const;
    double parseDouble () const;
    double parseDouble (double errorValue) const;
    float parseFloat () const;
    float parseFloat (float errorValue) const;
    bool parseBool () const;
    Variant& operator = (const Variant& v);
    Variant& operator = (tresult t);
    Variant& operator = (int64 l);
    Variant& operator = (uint64 l);
    Variant& operator = (int l);
    Variant& operator = (uint32 l);
    Variant& operator = (int16 l);
    Variant& operator = (uint16 l);
    Variant& operator = (int8 l);
    Variant& operator = (uint8 l);
    Variant& operator = (bool b);
    Variant& operator = (double f);
    Variant& operator = (float f);
    Variant& operator = (StringRef s);
    Variant& operator = (const char* s);
    Variant& operator = (IUnknown* obj);

    template  <class T>
    Variant& operator = (const UnknownPtr <T>& ptr);

    template  <class T>
    Variant& operator = (const AutoPtr <T>& ptr);

    template  <class T>
    Variant& operator = (const SharedPtr <T>& ptr);

    Variant& takeShared (IUnknown* o);
    bool operator == (const Variant& v) const;
    bool operator != (const Variant& v) const;
    bool operator > (const Variant& v) const;
    bool operator < (const Variant& v) const;
    int compare (const Variant& v) const;
    operator String () const;
    operator IUnknown * () const;
    operator int64 () const;
    operator uint64 () const;
    operator int () const;
    operator uint32 () const;
    operator int16 () const;
    operator uint16 () const;
    operator int8 () const;
    operator uint8 () const;
    operator double () const;
    operator float () const;
    operator bool () const;
    String asString () const;
    IUnknown* asUnknown () const;
    int64 asLargeInt () const;
    uint64 asLargeUInt () const;
    int asInt () const;
    uint32 asUInt () const;
    double asDouble () const;
    float asFloat () const;
    bool asBool () const;
    tresult asResult () const;
    UIntPtr asIntPointer () const;
    Variant& setIntPointer (UIntPtr p);
};