PDGE_DependencyOwner.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 __PDGE_DEPENDENCY_OWNER_H__
#define __PDGE_DEPENDENCY_OWNER_H__

#include "PDGE_API.h"
#include "PDGE_Dependency.h"

#include <UT/UT_Array.h>
#include <UT/UT_Assert.h>
#include <UT/UT_NonCopyable.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>

class PDGE_Evaluator;
class PDGE_Resolutions;

/**
 * Base class for objects that own dependencies
 */
class PDGE_API PDGE_DependencyOwner
{
public:
    using Array = UT_Array<PDGE_DependencyOwner*>;
    using Set   = UT_ArraySet<PDGE_DependencyOwner*>;

public:
    /// Constructs a new dependency owner, which must have a string name
                                    PDGE_DependencyOwner() {}
    virtual                         ~PDGE_DependencyOwner() {}

                                    UT_NON_COPYABLE(PDGE_DependencyOwner)

    /// Returns the memory usage of this owner instance
    virtual int64                   getMemoryUsage(bool inclusive) const
                                        {
                                            int64 mem = inclusive ? sizeof(*this) : 0;
                                            mem += myPropagateSet.getMemoryUsage(false);
                                            return mem;
                                        }

    /// Resets the owner
    virtual void                    resetOwner()
                                        { myPropagateSet.clear(); }

    /// Debug name for this dependency owner object, used when various debug
    /// utilities are enabled
    virtual UT_StringHolder         debugName() const = 0;

    /// Debug name for the dependency group this owner is in, used for DOT
    /// graph output when enabled.
    virtual UT_StringHolder         debugGroup() const
                                        { return debugName(); }

    /// Converts an owner array to an array of the specified type
    template <typename T>
    static inline void              cast(UT_Array<T>& out, const Array& in)
                                        {
                                            out.setCapacity(in.size());
                                            for (auto&& input : in)
                                                out.append((T)(input));
                                        }

    /// Converts an array of the specified type to an owner array
    template <typename T>
    static inline void              cast(Array& out, const UT_Array<T>& in)
                                        {
                                            out.setCapacity(in.size());
                                            for (auto&& input : in)
                                                out.append(input);
                                        }

    template <typename T>
    static inline void              cast(
                                        Array& out,
                                        const UT_Array<UT_UniquePtr<T>>& in)
                                        {
                                            out.setCapacity(in.size());
                                            for (auto&& input : in)
                                                out.append(input.get());
                                        }
protected:
    friend class PDGE_Dependency;
    friend class PDGE_PropagateGroup;

    /// Called when a dependency owned by this object is resolved
    virtual PDGE_Dependency::State  evalResolve(PDGE_Resolutions&,
                                                const PDGE_Evaluator&,
                                                PDGE_Dependency*)
                                        {
                                            UT_ASSERT(false);
                                            return PDGE_Dependency::eSucceeded;
                                        }

    /// Called when a dependency owned by this object is unresolved
    /// during an evaluation. This method is not called for normal
    /// reset calls between evaluations, or when a dependency object
    /// is destroyed. It also cannot be used to add new dependencies or
    /// trigger evaluation of existing ones, however it can return back
    /// additional dependencies that should be unresolved.
    virtual int                     evalUnresolve(PDGE_Dependency::Array&,
                                                  PDGE_Dependency*)
                                        {
                                            return 0;
                                        }

    /// Called when a dependency owned by this object receives a partial
    /// resolve notification.
    virtual PDGE_Dependency::State  evalPartial(PDGE_Resolutions&,
                                                const PDGE_Evaluator&,
                                                PDGE_Dependency*,
                                                const Array&)
                                        {
                                            UT_ASSERT(false);
                                            return PDGE_Dependency::eSucceeded;
                                        }

    /// Returns the propagate set for this owner
    inline const PDGE_Dependency::Set&
                                    propagateSet()
                                        { return myPropagateSet; }

    /// Adds an entry to the propagate set
    inline void                     addPropagate(PDGE_Dependency* dependency)
                                        { myPropagateSet.insert(dependency); }

private:
    /// Propagate set, used by PDGE_PropgateGroup
    PDGE_Dependency::Set            myPropagateSet;
};

#endif