PDG_AttributeEvaluator.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_EVALUATOR_H__
#define __PDG_ATTRIBUTE_EVALUATOR_H__

#include "PDG_API.h"

#include "PDG_AttributeQuery.h"
#include "PDG_AttributeTypes.h"

#include <UT/UT_AttributeEvaluator.h>
#include <UT/UT_StringHolder.h>

class PDG_AttributeOwner;
class PDG_EvaluationContext;
class PDG_Node;
class PDG_WorkItem;

/**
 * Caches an attribute name and component, for use with @ expression in HScript
 */
class PDG_API PDG_AttributeEvaluator : public UT_AttributeEvaluator
{
public:
    /// Controls whether or not string/file attributes should be localized
    /// when evaluated
    enum Localize
    {
        /// The raw, unlocalized value is always returned
        eLocalizeNever,

        /// The default behavior is the evaluating context is used
        eLocalizeDefault,

        /// The localizd value is always returned
        eLocalizeAlways
    };

public:
                            PDG_AttributeEvaluator(const char* name);
                            PDG_AttributeEvaluator(
                                    const char* name,
                                    int component);
                            PDG_AttributeEvaluator(
                                    PDG_AttributeIntrinsic type,
                                    int component);
                            ~PDG_AttributeEvaluator() override;

    /// PDG doesn't know about CH or time, so it must be told about the
    /// evaluation frame from the caller, e.g. via the TOP subclass of this
    /// evaluator type.
    bool                    evaluateAtFrameF(
                                fpreal frame,
                                int thread,
                                fpreal &result,
                                EvalDiagnostics &diagnostics) const;
    bool                    evaluateAtFrameS(
                                fpreal frame,
                                int thread,
                                UT_StringHolder &result,
                                EvalDiagnostics &diagnostics) const;

    bool                    evaluateF(
                                int thread,
                                fpreal &result,
                                EvalDiagnostics &diagnostics) const override
                                {
                                    return evaluateAtFrameF(
                                        0.0f,
                                        thread,
                                        result,
                                        diagnostics);
                                }

    bool                    evaluateS(
                                int thread,
                                UT_StringHolder &result,
                                EvalDiagnostics &diagnostics) const override
                                {
                                    return evaluateAtFrameS(
                                        0.0f,
                                        thread,
                                        result,
                                        diagnostics);
                                }

    bool                    isStringValue() const override;

    PDG_AttributeIntrinsic  attributeType() const;
    void                    setMetadata(
                                const UT_StringHolder& tag,
                                Localize localize,
                                bool all_values);

    Localize                localize() const
                                { return myLocalize; }
    bool                    isAllValues() const
                                { return myIsAllValues; }
    const UT_StringHolder&  tag() const
                                { return myTag; }
    const PDG_AttributeQuery&
                            query() const
                                { return myQuery; }

    void                    checkTimeDependent();


    static void             recordAttribute(const UT_StringHolder& name,
                                            int thread);

    static bool             isSuppressWarnings();
    static bool             setSuppressWarnings(bool suppress);

    static bool             hasAttribute(
                                int thread,
                                const char* name,
                                bool check_intrinsic);

private:
    void                    reportWarning(
                                PDG_AttributeCast cast_result,
                                exint query_index,
                                const PDG_AttributeOwner* owner,
                                const PDG_Node* node,
                                bool is_string,
                                int thread) const;
    void                    recordAttribute(
                                PDG_EvaluationContext* ctx,
                                int thread) const;

    bool                    isInputFile() const;
    bool                    isOutputFile() const;

private:
    PDG_AttributeQuery      myQuery;
    UT_StringHolder         myTag;
    PDG_AttributeIntrinsic  myAttributeType;
    Localize                myLocalize;
    bool                    myIsAllValues;
};

#endif