PDGT_TypeInstance.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_ENUM_TYPE_INSTANCE_H__
#define __PDGT_ENUM_TYPE_INSTANCE_H__

#include "PDGT_API.h"

#include "PDGT_BaseType.h"
#include "PDGT_ValueArgs.h"

#include <UT/UT_NonCopyable.h>

/**
 * The base class for all instances created using a PDGT_RegisteredType. The
 * Class argument to the registered type should derive from this class.
 *
 * This class provides basic functionality common to all instances, such as:
 *
 *      Providing the ability to look up a back reference to the type object
 *      Tracking whether or not the instance is currently being reloaded.
 *
 * This class also defines the `reloadInstance` virtual method, which is called
 * when the instance should reload itself. Typically, the instance will need
 * to implement a custom method that calls `type()->reloadInstance(...)` with
 * itself as an argument, and the various other construction arguments needed
 * in order to properly re-initialize the underyling object.
 *
 * For example, nodes based on Python classes needed to reconstruct their
 * underyling Python instance, which requires passing in the PDG_Node as a
 * construction argument. PDG_NodeCallback, which is a subclass of this class,
 * defines a custom `reloadInstance` method that makes the correct call into
 * its PDG_NodeCallbackType::reloadInstance method with the PDG_Node as an
 * argument.
 */
template <typename EnumType>
class PDGT_API_TMPL PDGT_TypeInstance : UT_NonCopyable
{
public:
    using BaseType  = PDGT_BaseType<EnumType>;

public:
    PDGT_TypeInstance()
        : myBaseType(nullptr)
        , myReloading(false) {}

    PDGT_TypeInstance(const PDGT_BaseType<EnumType>* base_type,
                      const PDGT_ValueArgs& extra_args)
        : myBaseType(base_type)
        , myExtraArgs(extra_args)
        , myReloading(false)
    {
        if (myBaseType)
            myBaseType->instanceCreated();
    }

    virtual                 ~PDGT_TypeInstance()
                                {
                                    if (myBaseType)
                                        myBaseType->instanceDestroyed();
                                }

    virtual int64           getMemoryUsage(bool inclusive) const
                                {
                                    int64 mem = inclusive ? sizeof(*this) : 0;
                                    mem += myExtraArgs.getMemoryUsage(false);
                                    return mem;
                                }

    virtual bool            reloadInstance(UT_WorkBuffer& errors)
                                { return false; }

    const BaseType*         type() const
                                { return myBaseType; }
    const UT_StringHolder&  typeName() const
                                { return myBaseType->typeName(); }
    const PDGT_ValueArgs&   extraArgs() const
                                { return myExtraArgs; }

    bool                    compareType(const BaseType* other_type,
                                        bool deep=true) const
                                {
                                    return myBaseType->compareType(other_type,
                                        deep);
                                }
 
    void                    setReloading(bool is_reloading)
                                { myReloading = is_reloading; }
    bool                    isReloading() const
                                { return myReloading; }

protected:
    const BaseType*         myBaseType;
    PDGT_ValueArgs          myExtraArgs;
    bool                    myReloading;
};

#endif