PDG_AttributeInfo.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_INFO_H__
#define __PDG_ATTRIBUTE_INFO_H__

#include "PDG_API.h"

#include <UT/UT_ArrayStringMap.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_StringSet.h>

class PDG_NodeInterface;

class UT_JSONValueArray;
class UT_WorkBuffer;

/**
 * Stores information about the attributes needed and created by a node
 */
class PDG_API PDG_AttributeInfo
{
public:
    /// Whether the attributes is create/used in the generate/cook stage
    enum AttribOrigin
    {
        eOriginNone     = 0x0,
        eOriginGenerate = 0x1,
        eOriginCook     = 0x2,
        eOriginExpected = 0x4,

        eOriginGenerateExpected = eOriginGenerate | eOriginExpected,
    };

    /// Configuration struct which can be used at either the node template or
    /// node instance level.
    struct PDG_API Config
    {
                                Config() : myDefaultOrigin(eOriginNone) {}

                                bool contains(const UT_StringHolder& name) const
                                    { return myOrigins.contains(name); }

        UT_ArrayStringMap<int>  myOrigins;
        int                     myDefaultOrigin;
    };

    /// Utility struct for information record about attributes used in
    /// expressions
    struct PDG_API ExprData
    {
        UT_StringMap<UT_StringSet>  myChannelAttributes;
        UT_ArrayStringMap<int>      myAttributeCounts;
    };

public:

    /// Default attribute origins are initialized to static
                            PDG_AttributeInfo();

    /// Resets the internal structures of this object. Called during a cook,
    /// so the info can be re-filled from the inputs, node options and parms
    void                    reset();


    /// Adds the attributes from the maap to the output map of this object
    void                    addOutputAttribs(const Config& attrib_config);

    /// Adds attributes that are consumed by this object
    void                    addInputAttribs(const Config& attrib_config);

    /// Adds the input attributes from the attribute info to the input map of
    /// this object
    void                    addUpstreamAttribs(const PDG_AttributeInfo& info,
                                               bool dynamic_generator);

    /// Copies expression attributes to inputs based on the port map
    void                    processExpressionAttribs(
                                        const PDG_NodeInterface* node_interface,
                                        const UT_ArrayStringMap<int>& ports);

    /// Returns true if the node needs to be dynamic in order to access the
    /// attributes it needs to generate.
    bool                    checkNeedsDynamic(
                                        bool require_inputs) const;

    /// Returns the output attribute map, i.e. attributes produced by the node
    /// that owns this object
    const Config&           outputAttributes() const
                                { return myOutputAttributes; }

    /// Utility that returns true if the specified output attribute exists
    bool                    hasOutputAttribute(
                                    const UT_StringHolder& name) const
                                {
                                    return myOutputAttributes.contains(name);
                                }

    /// Returns the attributes referenced or use during the current cook
    const Config&           inputAttributes() const
                                { return myInputAttributes; }

    /// Utility that returns true if the specified input attribute exists
    bool                    hasInputAttribute(
                                    const UT_StringHolder& name) const
                                {
                                    return myInputAttributes.contains(name);
                                }

    /// Returns the upstream attribute map, i.e. the total set of all upstream
    /// attributes that might be available to work items in this node.
    const Config&           upstreamAttributes() const
                                { return myUpstreamAttributes; }

    /// Utility that returns true if the specified upstream attribute exists
    bool                    hasUpstreamAttribute(
                                    const UT_StringHolder& name) const
                                {
                                    return myUpstreamAttributes.contains(name);
                                }

    /// Loads a Config object from a JSON array.
    static bool             fromJSON(
                                Config& config,
                                const UT_JSONValueArray& json_array,
                                UT_WorkBuffer& errors);

private:
    Config                  myOutputAttributes;
    Config                  myInputAttributes;
    Config                  myUpstreamAttributes;

    bool                    myHasDynamicInputs;
};

#endif