UT_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:
 *      This is a base class for custom attribute evaluators used with the
 *      @ function in HScript. Currently used by SOPs, LOPs and PDG.
 *
 *      The constructor will parse the attribute name to determine if there
 *      is a component number or letter. For example, @foo.x, @color.r,
 *      @coord.u or @pdg_input.5.
 *
 *      Optionally, it can also be configured to check for a color :pad 
 *      value. This is currently only used by PDG attributes. For example,
 *      @pdg_index:4 to pad the index value to 4 digits. The color must
 *      be processed prior to the component extension to allow for the
 *      syntax @attrib.y:2.
 */

#ifndef __UT_AttributeEvaluator_h__
#define __UT_AttributeEvaluator_h__

#include "UT_String.h"
#include "UT_StringHolder.h"
#include "UT_Error.h"
#include "UT_NonCopyable.h"

class UT_API UT_AttributeEvaluator
{
public:
    UT_AttributeEvaluator(const char *name, bool check_pad=false);
    virtual ~UT_AttributeEvaluator();

    UT_NON_COPYABLE(UT_AttributeEvaluator)

    class EvalDiagnostics
    {
    public:
                                EvalDiagnostics()
                                    : myErrorSeverity(UT_ERROR_NONE)
                                { }

        UT_ErrorSeverity        myErrorSeverity;
        UT_StringHolder         myErrorString;
    };

    enum EvalType
    {
        EVAL_OP_NODE,
        EVAL_CONTEXT_OPTION,
        EVAL_PDG,
        EVAL_COUNT
    };

    const UT_String&            name() const
                                { return myName; }
    int                         component() const
                                { return myComponent; }
    int                         padding() const
                                { return myPadding; }

    bool                        isTimeDependent() const
                                { return myTimeDep; }
    bool                        isLocalVar() const
                                { return myIsLocalVar; }
    bool                        hasComponent() const
                                { return myHasComponent; }
    bool                        needsToBeDeleted() const
                                { return myNeedsToBeDeleted; }

    // Provide default implementations in case a particular evaluator only
    // wants to provide one or the other.
    virtual bool                evaluateF(int thread, fpreal &result,
                                        EvalDiagnostics &diagnostics) const
                                { return 0.0; }
    virtual bool                evaluateS(int thread, UT_StringHolder &result,
                                        EvalDiagnostics &diagnostics) const
                                { return UT_StringHolder::theEmptyString; }
    virtual bool                isStringValue() const
                                { return false; }
    virtual bool                isValid() const
                                { return true; }

    // Copy all our internal data from another attribute evaluator. This is
    // used by the sop_PDGAttributeEvaluator which wraps one evaluator around
    // another.
    void                        copyFrom(const UT_AttributeEvaluator &src)
                                {
                                    myName = src.myName;
                                    myComponent = src.myComponent;
                                    myPadding = src.myPadding;
                                    myTimeDep = src.myTimeDep;
                                    myIsLocalVar = src.myIsLocalVar;
                                    myHasComponent = src.myHasComponent;
                                    myNeedsToBeDeleted = src.myNeedsToBeDeleted;
                                }

    // Returns the evaluator type for the specified prefix. Returns
    // EVAL_COUNT if the prefix is invalid.
    static EvalType             typeFromPrefix(const char* prefix);

protected:
    UT_String                   myName;
    int                         myComponent;
    int                         myPadding;
    bool                        myTimeDep;
    bool                        myIsLocalVar;
    bool                        myHasComponent;
    bool                        myNeedsToBeDeleted;
};

#endif