UT_PathPattern.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.
 *
 */

#ifndef __UT_PathPattern_h__
#define __UT_PathPattern_h__

#include "UT_API.h"
#include "UT_Array.h"
#include "UT_IntArray.h"
#include "UT_IntrusivePtr.h"
#include "UT_StringHolder.h"
#include "UT_StringArray.h"
#include "UT_UniquePtr.h"

class UT_SpecialTokenData : public UT_IntrusiveRefCounter<UT_SpecialTokenData>
{
public:
                         UT_SpecialTokenData()
                         { }
    virtual             ~UT_SpecialTokenData()
                         { }
};
typedef UT_IntrusivePtr<UT_SpecialTokenData> UT_SpecialTokenDataPtr;

// Matches a pattern against a USD path. The pattern uses roughly rsync style
// matching, where "*" only matches within a path component, and "**" matches
// across path components. Also supports standard Houdini "^" operator to
// exclude paths. In addition, "-" will also exclude paths, "&" will perform
// intersections between two sets of paths, and "~" can be used to quickly
// prune branches during a full traversal of the path hierarchy.
class UT_API UT_PathPattern
{
public:
                         UT_PathPattern(const UT_StringRef &pattern,
                                 bool case_sensitive = true,
                                 bool assume_wildcards = false);
    virtual             ~UT_PathPattern();

    bool                 matches(const UT_StringRef &path,
                                bool *excludes_branch = nullptr) const;
    bool                 getExplicitList(UT_StringArray &tokens) const;

    bool                 getCaseSensitive() const
                         { return myCaseSensitive; }
    bool                 getAssumeWildcardsAroundPlainTokens() const
                         { return myAssumeWildcardsAroundPlainTokens; }
    const UT_StringHolder &getPatternError() const
                         { return myPatternError; }

protected:
    class Token {
    public:
                         Token(const UT_StringHolder &str,
                                 bool do_path_matching,
                                 bool has_wildcards)
                            : myString(str),
                              myDoPathMatching(do_path_matching),
                              myHasWildcards(has_wildcards),
                              myIsSpecialToken(false)
                         { }
                        ~Token()
                         { }

        UT_StringHolder          myString;
        UT_SpecialTokenDataPtr   mySpecialTokenDataPtr;
        bool                     myDoPathMatching;
        bool                     myHasWildcards;
        bool                     myIsSpecialToken;
    };

    // Default constructor, only to be used by createEmptyClone, which is used
    // by create* functions to build a new patterns from pieces of the current
    // pattern.
                         UT_PathPattern(bool case_sensitive,
                                 bool assume_wildcards);

    UT_PathPattern      *createPruningPattern(int tokenidx);
    UT_PathPattern      *createPrecedingGroupPattern(int tokenidx);
    virtual UT_PathPattern *createEmptyClone() const
                         {
                             return new UT_PathPattern(myCaseSensitive,
                                 myAssumeWildcardsAroundPlainTokens);
                         }
    virtual bool         matchSpecialToken(
                                const UT_StringRef &path,
                                const Token &token,
                                bool *excludes_branch) const;
    void                 testForExplicitList();

    UT_Array<Token>      myTokens;

private:
    // This class is used to represent the parsed expression tree generated
    // from a string search pattern.
    class PatternOp {
    public:
        enum Operator {
            GROUP,
            NOOP,
            VALUES,
            ADD,
            SUBTRACT,
            PRUNE,
            INTERSECT
        };

                         PatternOp(const UT_PathPattern &owner)
                             : myOwner(owner),
                               myParent(nullptr),
                               myOp(GROUP),
                               myLeftOp(nullptr),
                               myRightOp(nullptr)
                         { }
                         PatternOp(PatternOp &parent, Operator op)
                             : myOwner(parent.myOwner),
                               myParent(&parent),
                               myOp(op),
                               myLeftOp(nullptr),
                               myRightOp(nullptr)
                         { }
                        ~PatternOp()
                         {
                             delete myLeftOp;
                             delete myRightOp;
                         }

        PatternOp       *push(Operator op);
        PatternOp       *insertGroup();
        bool             containsOnlyAddOperations() const;

        const UT_PathPattern    &myOwner;
        Operator                 myOp;
        PatternOp               *myParent;
        PatternOp               *myLeftOp;
        PatternOp               *myRightOp;
        UT_IntArray              myValues;
    };

    class PatternOpStep
    {
    public:
        PatternOpStep(PatternOp *op = nullptr)
            : myPatternOp(op), myFollowLeftChild(false) { }

        PatternOp               *myPatternOp;
        bool                     myFollowLeftChild;
    };

    typedef UT_Array<PatternOpStep> PatternOpPath;

    void                         init(const UT_StringArray &pattern_tokens);
    bool                         matches(const UT_StringRef &path,
                                        PatternOp *op,
                                        bool *excludes_branch) const;
    void                         printPattern(const PatternOp *patternop,
                                        int indent);
    static bool                  findToken(int tokenidx,
                                        PatternOpPath &oppath);
    static PatternOp            *duplicatePatternOp(
                                        const UT_PathPattern &pattern,
                                        const PatternOp *patternop,
                                        PatternOp *parent);
    static bool                  patternOpPathContains(
                                        const PatternOpPath &oppath,
                                        const PatternOp *patternop);
    static bool                  patternOpPathIntersects(
                                        const PatternOpPath &oppath,
                                        const PatternOp *patternop);
    static void                  makePruningPatternOp(
                                        PatternOp *patternop,
                                        const PatternOpPath &oppath);
    static void                  makePrecedingGroupPatternOp(
                                        PatternOp *patternop,
                                        const PatternOpPath &oppath,
                                        bool &found_token);
    static bool                  parsePattern(const char *&pattern,
                                        UT_StringArray &tokens,
                                        PatternOp *groupop,
                                        UT_String &error);

    UT_UniquePtr<PatternOp>      myPatternOp;
    UT_StringHolder              myPatternError;
    bool                         myIsExplicitList;
    // These values can't change after the constructor, because the
    // constructor can cause evaluation of the pattern or parts of it.
    const bool                   myCaseSensitive;
    const bool                   myAssumeWildcardsAroundPlainTokens;
};

#endif