pathExpression.h

//
// Copyright 2023 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache License.
//
#ifndef PXR_USD_SDF_PATH_EXPRESSION_H
#define PXR_USD_SDF_PATH_EXPRESSION_H
 
#include "pxr/pxr.h"
#include "pxr/usd/sdf/api.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/usd/sdf/predicateExpression.h"
#include "pxr/base/tf/hash.h"
 
#include <iosfwd>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class SdfPathExpression
{
public:
    class PathPattern
    {
    public:
        SDF_API
        PathPattern();
 
        struct Component {
            bool IsStretch() const {
                return predicateIndex == -1 && text.empty();
            }
 
            std::string text;
            int predicateIndex = -1;
            bool isLiteral = false;
 
            friend bool operator==(Component const &l, Component const &r) {
                return std::tie(l.text, l.predicateIndex, l.isLiteral) ==
                    std::tie(r.text, r.predicateIndex, r.isLiteral);
            }
            
            friend bool operator!=(Component const &l, Component const &r) {
                return !(l == r);
            }
 
            template <class HashState>
            friend void TfHashAppend(HashState &h, Component const &c) {
                h.Append(c.text, c.predicateIndex, c.isLiteral);
            }
 
            friend void swap(Component &l, Component &r) {
                auto lt = std::tie(l.text, l.predicateIndex, l.isLiteral);
                auto rt = std::tie(r.text, r.predicateIndex, r.isLiteral);
                swap(lt, rt);
            }
        };
 
        SDF_API
        void AppendChild(std::string const &text,
                         SdfPredicateExpression &&predExpr);
        SDF_API
        void AppendChild(std::string const &text,
                         SdfPredicateExpression const &predExpr);
        SDF_API
        void AppendChild(std::string const &text);
 
        SDF_API
        void AppendProperty(std::string const &text,
                            SdfPredicateExpression &&predExpr);
        SDF_API
        void AppendProperty(std::string const &text,
                            SdfPredicateExpression const &predExpr);
        SDF_API
        void AppendProperty(std::string const &text);
 
        SdfPath const &GetPrefix() const & {
            return _prefix;
        }
 
        SdfPath GetPrefix() && {
            return std::move(_prefix);
        }
 
        SDF_API
        void SetPrefix(SdfPath &&p);
 
        void SetPrefix(SdfPath const &p) {
            SetPrefix(SdfPath(p));
        }
 
        SDF_API
        std::string GetText() const;
 
        std::vector<Component> const &GetComponents() const & {
            return _components;
        }
        
        std::vector<Component> GetComponents() && {
            return _components;
        }
 
        std::vector<SdfPredicateExpression> const &
        GetPredicateExprs() const & {
            return _predExprs;
        }
        
        std::vector<SdfPredicateExpression>
        GetPredicateExprs() && {
            return _predExprs;
        }
 
        bool IsProperty() const {
            return _isProperty;
        }
 
        explicit operator bool() const {
            return !_prefix.IsEmpty();
        }
 
    private:
        template <class HashState>
        friend void TfHashAppend(HashState &h, PathPattern const &pat) {
            h.Append(pat._prefix, pat._components,
                     pat._predExprs, pat._isProperty);
        }
 
        friend bool
        operator==(PathPattern const &l, PathPattern const &r) {
            return std::tie(l._prefix, l._components,
                            l._predExprs, l._isProperty) ==
                   std::tie(r._prefix, r._components,
                            r._predExprs, r._isProperty);
        }
 
        friend bool
        operator!=(PathPattern const &l, PathPattern const &r) {
            return !(l == r);
        }
 
        friend void swap(PathPattern &l, PathPattern &r) {
            auto lt = std::tie(
                l._prefix, l._components, l._predExprs, l._isProperty);
            auto rt = std::tie(
                r._prefix, r._components, r._predExprs, r._isProperty);
            swap(lt, rt);
        }
        
        SdfPath _prefix;
        std::vector<Component> _components;
        std::vector<SdfPredicateExpression> _predExprs;
        bool _isProperty;
    };
 
    class ExpressionReference {
    public:
        SDF_API
        static ExpressionReference const &Weaker();
        
        // Optional path reference, can be empty for "weaker" references (name
        // is "_") or for references to local or otherwise "named" collections.
        SdfPath path;
        
        // Name is either a property name, or "_" (meaning the weaker
        // collection).  If the name is "_", the path must be empty.
        std::string name;
 
        template <class HashState>
        friend void TfHashAppend(HashState &h, ExpressionReference const &er) {
            h.Append(er.path, er.name);
        }
 
        friend bool
        operator==(ExpressionReference const &l, ExpressionReference const &r) {
            return std::tie(l.path, l.name) == std::tie(r.path, r.name);
        }
        
        friend bool
        operator!=(ExpressionReference const &l, ExpressionReference const &r) {
            return !(l == r);
        }
 
        friend void swap(ExpressionReference &l, ExpressionReference &r) {
            auto lt = std::tie(l.path, l.name);
            auto rt = std::tie(r.path, r.name);
            swap(lt, rt);
        }
    };
 
    enum Op {
        // Operations on atoms.
        Complement,
        ImpliedUnion,
        Union,
        Intersection,
        Difference,
 
        // Atoms.
        ExpressionRef,
        Pattern
    };
 
    SdfPathExpression() = default;
 
    SDF_API
    explicit SdfPathExpression(std::string const &expr,
                               std::string const &parseContext = {});
 
    SDF_API
    static SdfPathExpression const &Everything();
 
    SDF_API
    static SdfPathExpression const &EveryDescendant();
 
    SDF_API
    static SdfPathExpression const &Nothing();
 
    SDF_API
    static SdfPathExpression const &WeakerRef();
    
    SDF_API
    static SdfPathExpression
    MakeComplement(SdfPathExpression &&right);
 
    static SdfPathExpression
    MakeComplement(SdfPathExpression const &right) {
        return MakeComplement(SdfPathExpression(right));
    }
 
    SDF_API
    static SdfPathExpression
    MakeOp(Op op, SdfPathExpression &&left, SdfPathExpression &&right);
 
    static SdfPathExpression
    MakeOp(Op op,
           SdfPathExpression const &left,
           SdfPathExpression const &right) {
        return MakeOp(op, SdfPathExpression(left), SdfPathExpression(right));
    }
 
    SDF_API
    static SdfPathExpression
    MakeAtom(ExpressionReference &&ref);
 
    static SdfPathExpression
    MakeAtom(ExpressionReference const &ref) {
        return MakeAtom(ExpressionReference(ref));
    }
 
    SDF_API
    static SdfPathExpression
    MakeAtom(PathPattern &&pattern);
 
    static SdfPathExpression
    MakeAtom(PathPattern const &pattern) {
        return MakeAtom(PathPattern(pattern));
    }
 
    SDF_API
    void Walk(TfFunctionRef<void (Op, int)> logic,
              TfFunctionRef<void (ExpressionReference const &)> ref,
              TfFunctionRef<void (PathPattern const &)> pattern) const;
 
    SDF_API
    void WalkWithOpStack(
        TfFunctionRef<void (std::vector<std::pair<Op, int>> const &)> logic,
        TfFunctionRef<void (ExpressionReference const &)> ref,
        TfFunctionRef<void (PathPattern const &)> pattern) const;
 
    SdfPathExpression
    ReplacePrefix(SdfPath const &oldPrefix,
                  SdfPath const &newPrefix) const & {
        return SdfPathExpression(*this).ReplacePrefix(oldPrefix, newPrefix);
    }
 
    SDF_API
    SdfPathExpression
    ReplacePrefix(SdfPath const &oldPrefix,
                  SdfPath const &newPrefix) &&;
 
    SDF_API
    bool IsAbsolute() const;
 
    SdfPathExpression
    MakeAbsolute(SdfPath const &anchor) const & {
        return SdfPathExpression(*this).MakeAbsolute(anchor);
    }
 
    SDF_API
    SdfPathExpression
    MakeAbsolute(SdfPath const &anchor) &&;
 
    bool ContainsExpressionReferences() const {
        return !_refs.empty();
    }
 
    SDF_API
    bool ContainsWeakerExpressionReference() const;
 
    SdfPathExpression
    ResolveReferences(
        TfFunctionRef<SdfPathExpression (
                          ExpressionReference const &)> resolve) const & {
        return SdfPathExpression(*this).ResolveReferences(resolve);
    }
 
    SDF_API
    SdfPathExpression
    ResolveReferences(
        TfFunctionRef<SdfPathExpression (
                          ExpressionReference const &)> resolve) &&;
    
    SdfPathExpression
    ComposeOver(SdfPathExpression const &weaker) const & {
        return SdfPathExpression(*this).ComposeOver(weaker);
    }
 
    SDF_API
    SdfPathExpression
    ComposeOver(SdfPathExpression const &weaker) &&;
 
    bool IsComplete() const {
        return !ContainsExpressionReferences() && IsAbsolute();
    }
 
    SDF_API
    std::string GetText() const;
 
    bool IsEmpty() const {
        return _ops.empty();
    }
    
    explicit operator bool() const {
        return !IsEmpty();
    }
 
    std::string const &GetParseError() const & {
        return _parseError;
    }
 
private:
    template <class HashState>
    friend void TfHashAppend(HashState &h, SdfPathExpression const &expr) {
        h.Append(expr._ops, expr._refs, expr._patterns, expr._parseError);
    }
 
    SDF_API
    friend std::ostream &
    operator<<(std::ostream &, SdfPathExpression const &);
 
    friend bool
    operator==(SdfPathExpression const &l, SdfPathExpression const &r) {
        return std::tie(l._ops, l._refs, l._patterns, l._parseError) ==
               std::tie(r._ops, r._refs, r._patterns, r._parseError);
    }
 
    friend bool
    operator!=(SdfPathExpression const &l, SdfPathExpression const &r) {
        return !(l == r);
    }
 
    friend void swap(SdfPathExpression &l, SdfPathExpression &r) {
        auto lt = std::tie(l._ops, l._refs, l._patterns, l._parseError);
        auto rt = std::tie(r._ops, r._refs, r._patterns, r._parseError);
        swap(lt, rt);
    }
 
    std::vector<Op> _ops;
    std::vector<ExpressionReference> _refs;
    std::vector<PathPattern> _patterns;
 
    // This member holds a parsing error string if this expression was
    // constructed by the parser and errors were encountered during the parsing.
    std::string _parseError;
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_SDF_PATH_EXPRESSION_H