PDG_AttributeGeometry.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_Geometry_H__
#define __PDG_ATTRIBUTE_Geometry_H__

#include "PDG_API.h"

#include "PDG_ApplicationShim.h"
#include "PDG_AttributeData.h"

#include <UT/UT_UniquePtr.h>
#include <type_traits>

class UT_JSONValue;
class UT_JSONWriter;
class UT_OptionsHolder;
class UT_StringHolder;

/**
 * Attribute that contains a single PDG_AttributeShim::Geometry* for storing
 * geometry on a work item.
 */
class PDG_API PDG_AttributeGeometry : public PDG_AttributeData
{
public:
    static constexpr PDG_AttributeType TypeEnum = PDG_AttributeType::eGeometry;

    using Geometry  = PDG_ApplicationShim::Geometry;
    using Data      = Geometry*;
    using Map       = UT_StringMap<Data>;

    using PDG_AttributeData::PDG_AttributeData;

public:
                                PDG_AttributeGeometry();
                                ~PDG_AttributeGeometry() 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;

    const Geometry*             geometry() const;
    Geometry*                   geometry();

    template <typename T>
    const T*                    geometryT() const
    {
        return dynamic_cast<const T*>(geometry());
    }

    template <typename T>
    T*                          geometryT()
    {
        return dynamic_cast<T*>(geometry());
    }

    bool                        desc(UT_StringHolder& str) const;

    inline bool                 hasData() const
    {
        return (myGeometry.get() != nullptr);
    }

    inline int                  size() const
    {
        return 1;
    }

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

    inline bool                 value(Data& geometry, int component) const
    {
        if (component != 0)
            return false;

        geometry = myGeometry.get();
        return true;
    }

    template <typename T>
    inline T*                   createGeometry()
    {
        myGeometry = UTmakeUnique<T>();
        return static_cast<T*>(myGeometry.get());
    }

    inline void                 swap(PDG_AttributeGeometry* other)
    {
        std::swap(myGeometry, other->myGeometry);
    }

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

private:
    UT_UniquePtr<Geometry>      myGeometry;
};

#endif