PDG_AttributePyObject.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 __PDG_ATTRIBUTE_PY_OBJECT_H__
#define __PDG_ATTRIBUTE_PY_OBJECT_H__

#include "PDG_API.h"

#include "PDG_AttributeData.h"

#include <UT/UT_StringMap.h>

class PDG_AttributeQuery;
class PY_PyObject;
class UT_JSONValue;
class UT_JSONWriter;
class UT_OptionsHolder;
class UT_StringHolder;

/**
 * Attribute that contains a single PY_PyObject*, mostly opaque in C++ code but
 * accessible from the Python API.
 */
class PDG_API PDG_AttributePyObject : public PDG_AttributeData
{
public:
    static constexpr PDG_AttributeType TypeEnum = PDG_AttributeType::ePythonObject;

    using Data  = PY_PyObject*;
    using Map   = UT_StringMap<Data>;
    using PDG_AttributeData::PDG_AttributeData;

public:
    PDG_AttributePyObject();
    explicit PDG_AttributePyObject(PY_PyObject* object);
    ~PDG_AttributePyObject() override;

    int64                       getMemoryUsage(bool inclusive) const override;
    bool                        hash(
                                    SYS_HashType& hash_value,
                                    exint index,
                                    UT_WorkBuffer& errors) const override;
    PDG_AttributeData*          clone() const override;

    bool                        saveData(UT_JSONWriter& writer) const override;
    void                        saveData(
                                    const UT_StringHolder& key,
                                    UT_OptionsHolder& dict) const override;

    bool                        loadData(const UT_JSONValue& value) override;
    bool                        loadData(
                                    const UT_StringHolder& key,
                                    const UT_OptionsHolder& dict) override;

    bool                        compare(
                                    const PDG_AttributeData* other
                                    ) const override;
    PDG_AttributeMergeError     merge(
                                    PDG_AttributeMergeOp merge_op,
                                    int stride) override;

    PDG_AttributeCast           query(
                                    fpreal& value,
                                    const PDG_AttributeQuery& query,
                                    int component) const;
    PDG_AttributeCast           query(
                                    fpreal& value,
                                    const UT_StringHolder& str,
                                    int component) const;

    PDG_AttributeCast           query(
                                    UT_WorkBuffer& value,
                                    const PDG_AttributeQuery& query,
                                    int component) const;
    PDG_AttributeCast           query(
                                    UT_WorkBuffer& value,
                                    const UT_StringHolder& str,
                                    int component) const;

    PY_PyObject*                query(const UT_StringHolder& str) const;

    bool                        setObjectFromString(const UT_StringHolder& repr);
    bool                        setObjectFromLiteral(
                                    const UT_StringHolder& literal,
                                    UT_WorkBuffer& errors);

    PY_PyObject*                object() const;
    void                        setObject(PY_PyObject* object);

    inline bool                 hasData() const
    {
        return (myObject != nullptr);
    }

    inline int                  size() const
    {
        return 1;
    }

    inline bool                 valid(int component) const
    {
        return (component == 0);
    }

    inline bool                 value(PY_PyObject*& object, int component) const
    {
        if (component != 0)
            return false;

        object = myObject;
        return true;
    }

    inline void                 setValue(PY_PyObject* object, int index)
    {
        setObject(object);
    }

    bool                        repr(UT_WorkBuffer& str) const;
    bool                        repr(UT_StringHolder& str) const;
    bool                        str(UT_StringHolder& str) const;

    inline void                 swap(PDG_AttributePyObject* other)
    {
        std::swap(myObject, other->myObject);
    }

    void                        copy(
                                    const PDG_AttributePyObject* other,
                                    PDG_AttributeCopyOp copy_op);

private:
    void                        serializationRepr(
                                    UT_StringHolder& object_repr) const;
    PY_PyObject*                queryInternal(
                                    const PDG_AttributeQuery& query,
                                    int component) const;
    static PY_PyObject*         getItem(PY_PyObject* source,
                                        const UT_StringHolder& key);
    static PY_PyObject*         getItem(PY_PyObject* source, int key);

    static PDG_AttributeCast
                                castValue(fpreal& value, PY_PyObject* object);
    static PDG_AttributeCast
                                castValue(UT_WorkBuffer& value,
                                          PY_PyObject* object);
private:
    PY_PyObject*                myObject;
};

#endif