PDG_FilterPattern.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_FILTER_PATTERN_H__
#define __PDG_FILTER_PATTERN_H__

#include "PDG_API.h"
#include "PDG_AttributeTypes.h"
#include "PDG_BasePattern.h"
#include "PDG_ValuePattern.h"

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

#include <SYS/SYS_Math.h>

class PDG_ValuePattern;
class PDG_WorkItem;

/**
 * Matches attribute or intrinsic names to filter ranges, for example:
 *
 * `@pdg_id=1,10,100-200`
 * `@scale.x>0.5 @scale.y<0.5`
 *
 * Multiple pattern entries can be specified, separated by a space.
 */
class PDG_API PDG_FilterPattern : public PDG_BasePattern
{
public:
                        PDG_FilterPattern();
                        PDG_FilterPattern(const UT_StringHolder& pattern);

                        PDG_FilterPattern(const PDG_FilterPattern&) = delete;
    PDG_FilterPattern&  operator=(const PDG_FilterPattern&) = delete;

    void                reset(const UT_StringHolder& pattern);

    bool                match(
                            const PDG_WorkItem* work_item,
                            bool inclusive) const;
    bool                match(
                            const UT_StringHolder& name,
                            const UT_StringHolder& value,
                            int component,
                            bool inclusive) const
                            {
                                return matchPattern(
                                    name, value, component, inclusive);
                            }

    bool                match(
                            const UT_StringHolder& name,
                            exint value,
                            int component,
                            bool inclusive) const
                            {
                                return matchPattern(
                                    name, value, component, inclusive);
                            }

    bool                match(
                            const UT_StringHolder& name,
                            fpreal value,
                            int component,
                            bool inclusive) const
                            {
                                return matchPattern(
                                    name, value, component, inclusive);
                            }

private:
    enum Operation
    {
        // @id=pattern or @id==pattern
        eOpEQ,

        // @id!=pattern
        eOpNE,

        // @id>pattern
        eOpGT,

        // @id>=pattern
        eOpGE,

        // @id<pattern
        eOpLT,

        // @id<=pattern
        eOpLE,
    };

    struct Entry
    {
                            Entry()
                                : myPattern(',')
                                , myComponent(0) {}

        UT_StringHolder     myAttribute;
        int                 myComponent;

        PDG_ValuePattern    myPattern;
        fpreal              myFloat;
        exint               myInteger;

        Operation           myOperator;

        bool                myHasFloat;
        bool                myHasInteger;

        bool                myIsExclusion;
    };

    using EntryPtr = UT_UniquePtr<Entry>;

private:
    bool                parse(const UT_StringHolder& pattern);

    bool                matchIntrinsic(
                            bool& result,
                            const PDG_WorkItem* work_item,
                            const EntryPtr& entry,
                            PDG_AttributeIntrinsic type,
                            bool inclusive) const;

    template <typename T>
    inline bool         matchPattern(
                            const UT_StringHolder& name,
                            const T& value,
                            int component,
                            bool inclusive) const
    {
        bool matched = false;
        for (auto&& entry : myPatternEntries)
        {
            if (entry->myAttribute != name || entry->myComponent != component)
                continue;

            if (matchEntry(*entry.get(), value, inclusive))
            {
                if (!myHasExclusions)
                    return true;
                matched = !entry->myIsExclusion;
            }
        }

        return matched;
    }

    inline bool         matchEntry(
                            const Entry& entry,
                            fpreal value,
                            bool inclusive) const
    {
        return compareNumeric(entry, value, inclusive);
    }

    inline bool         matchEntry(
                            const Entry& entry,
                            exint value, 
                            bool inclusive) const
    {
        return compareNumeric(entry, value, inclusive);
    }

    inline bool         matchEntry(
                            const Entry& entry,
                            const UT_StringHolder& value,
                            bool inclusive) const
    {
        if (entry.myOperator == eOpEQ)
        {
            if (entry.myPattern.isValid())
                return entry.myPattern.contains(value, inclusive);
            return false;
        }

        if (entry.myOperator == eOpNE)
        {
            if (entry.myPattern.isValid())
                return !entry.myPattern.contains(value, inclusive);
            return false;
        }

        return false;
    }

    template <typename T>
    inline bool         compareNumeric(
                            const Entry& entry,
                            const T& value,
                            bool inclusive) const
    {
        switch (entry.myOperator)
        {
            case eOpEQ:
            {
                if (entry.myHasFloat)
                    return SYSalmostEqual(entry.myFloat, value);
                if (entry.myHasInteger)
                    return entry.myInteger == value;
                if (entry.myPattern.isValid())
                    return entry.myPattern.contains(value, inclusive);
                return false;
            }

            case eOpNE:
            {
                if (entry.myHasFloat)
                    return !SYSalmostEqual(entry.myFloat, value);
                if (entry.myHasInteger)
                    return entry.myInteger != value;
                if (entry.myPattern.isValid())
                    return !entry.myPattern.contains(value, inclusive);
                return false;
            }

            case eOpGT:
            {
                if (entry.myHasFloat)
                    return entry.myFloat < value;
                if (entry.myHasInteger)
                    return entry.myInteger < value;
                return false;
            }

            case eOpGE:
            {
                if (entry.myHasFloat)
                    return entry.myFloat <= value;
                if (entry.myHasInteger)
                    return entry.myInteger <= value;
                return false;
            }

            case eOpLT:
            {
                if (entry.myHasFloat)
                    return entry.myFloat > value;
                if (entry.myHasInteger)
                    return entry.myInteger > value;
                return false;
            }

            case eOpLE:
            {
                if (entry.myHasFloat)
                    return entry.myFloat >= value;
                if (entry.myHasInteger)
                    return entry.myInteger >= value;
                return false;
            }

            default:
                return false;
        }
    }

private:
    UT_Array<EntryPtr>      myPatternEntries;
    bool                    myHasExclusions;
};

#endif