PDGT_Value.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * COMMENTS:
 */

#ifndef __PDGT_VALUE_H__
#define __PDGT_VALUE_H__

#include "PDGT_API.h"

#include <UT/UT_ArrayStringMap.h>
#include <UT/UT_StringHolder.h>

class PY_PyObject;
class UT_JSONValue;
class UT_JSONValueArray;
class UT_JSONWriter;
class UT_WorkBuffer;

class PDGT_API PDGT_Value
{    
public:
    using Map   = UT_ArrayStringMap<PDGT_Value>;
    using Array = UT_Array<PDGT_Value>;

    enum DataType
    {
        eInteger,
        eFloat,
        eString,
        ePythonObject,
        eInvalid
    };

    static UT_StringHolder  getDataTypeAsString(DataType type);

public:
                            PDGT_Value();
                            PDGT_Value(const PDGT_Value& other);

                            PDGT_Value(fpreal float_value);
                            PDGT_Value(exint int_value);
                            PDGT_Value(bool bool_value);
                            PDGT_Value(int int_value);
                            PDGT_Value(const char* str_value);
                            PDGT_Value(PY_PyObject* py_value);

                            ~PDGT_Value();

    PDGT_Value&             operator=(const PDGT_Value& other);

    bool                    operator==(const PDGT_Value& other) const;
    bool                    operator!=(const PDGT_Value& other) const;
   
    void                    setDataType(DataType data_type,
                                        bool initialize=false);

    void                    setFloatValue(fpreal float_value);
    void                    setIntValue(exint int_value);
    void                    setBoolValue(bool bool_value);
    void                    setStringValue(const char* str_value);
    void                    setPythonObjectValue(PY_PyObject* py_value);

    void                    setValue(const PDGT_Value& value);
    void                    setValue(fpreal float_value);
    void                    setValue(exint int_value);
    void                    setValue(int int_value);
    void                    setValue(bool bool_value);
    void                    setValue(const char* str_value);
    void                    setValue(PY_PyObject* py_object);

    void                    loadValue(
                                const UT_JSONValue& json_value,
                                DataType data_type);

    bool                    valid() const;
    DataType                dataType() const;

    fpreal                  floatValue() const;
    exint                   intValue() const;
    bool                    boolValue() const;
    const UT_StringHolder&  stringValue() const;
    PY_PyObject*            pyObjectValue() const;

    void                    value(fpreal& value) const;
    void                    value(exint& value) const;
    void                    value(int& value) const;
    void                    value(bool& value) const;
    void                    value(UT_StringHolder& value) const;

    UT_StringHolder         valueAsString(bool quoted=true) const;
    void                    valueAsString(UT_WorkBuffer& buffer,
                                          bool quoted=true) const;
    void                    valueToJSON(UT_JSONWriter& writer) const;

    static void             fromJSONArray(
                                Array& value_array,
                                const UT_JSONValueArray& json_array,
                                DataType data_type);

private:
    void                    freePyObject();
    void                    replacePyObject(PY_PyObject* other);

private:
    union PODData
    {
        fpreal              myFloatValue;
        exint               myIntValue;
        PY_PyObject*        myPyObjectValue;
    };

    UT_StringHolder         myStringValue;
    PODData                 myData;
    DataType                myDataType;
};

namespace UT
{
    template <typename T>
    struct DefaultClearer;

    template <>
    struct DefaultClearer<PDGT_Value>
    {
        static void         clear(PDGT_Value& value)
                                { value.setDataType(PDGT_Value::eInvalid); }
        static bool         isClear(const PDGT_Value& value)
                                { return value.valid(); }
        static void         clearConstruct(PDGT_Value *p)
                                { new ((void *)p) PDGT_Value(); }
        static const bool   clearNeedsDestruction = false;
    };
}

#endif /* __PDGT_VALUE_H__ */