PDG_Conditional.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_CONDITIONAL_H__
#define __PDG_CONDITIONAL_H__

#include "PDG_API.h"

#include "PDG_BasePattern.h"

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

class PDG_NodeInterface;
class PDG_Port;

/*
 * Conditional expression for PDG node templates
 */
class PDG_API PDG_Conditional : public PDG_BasePattern, UT_NonCopyable
{
public:
    /// Constructs a new conditional expression from the input string
                        PDG_Conditional(const UT_StringHolder& pattern);

    /// Checks if the condition is true or false for the specified node
    /// interface
    bool                match(const PDG_NodeInterface* interface,
                              bool expression_default=true) const;

    /// Resets the condition to the specified pattern
    bool                reset(const UT_StringHolder& pattern);

private:
    enum Operation
    {
        eEQ,
        eNE,
        eLT,
        eLE,
        eGT,
        eGE,
    };

    enum ConjunctionState
    {
        eBegin,
        eName,
        eOperator,
        eValue
    };

    struct Condition
    {
        UT_StringHolder myPortName;

        UT_StringHolder myString;
        fpreal          myFloat;
        exint           myInteger;

        Operation       myOperation;
        bool            myHasFloat;
        bool            myHasInteger;
    };

    using Conjunction   = UT_Array<Condition>;
    using Disjunction   = UT_Array<UT_UniquePtr<Conjunction>>;

private:
    template <typename T>
    static bool         compare(const T& left, const T& right, Operation op)
    {
        switch (op)
        {
            case eEQ:
                return (left == right);
            case eLT:
                return (left < right);
            case eLE:
                return (left <= right);
            case eGT:
                return (left > right);
            case eGE:
                return (left >= right);
            case eNE:
                return (left != right);
            default:
                return false;
        }
    }

    bool                parse(const UT_StringHolder& pattern);
    bool                matchPort(const Condition& condition,
                                  const PDG_Port* port) const;

    bool                parseConjunction(Conjunction& conjunction,
                                         const UT_StringView& view,
                                         int& index);
    bool                addCondition(Conjunction& conjunction,
                                     const UT_WorkBuffer& name,
                                     const UT_WorkBuffer& op,
                                     const UT_WorkBuffer& value);
private:
    Disjunction         myConditions;
};

#endif