dataSourceLocator.h

//
// Copyright 2021 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_IMAGING_HD_DATASOURCELOCATOR_H
#define PXR_IMAGING_HD_DATASOURCELOCATOR_H

#include "pxr/pxr.h"
#include "pxr/base/tf/token.h"
#include "pxr/base/tf/smallVector.h"
#include "pxr/base/tf/hash.h"

#include "pxr/imaging/hd/api.h"

PXR_NAMESPACE_OPEN_SCOPE

class HdDataSourceLocator
{
public:

    HD_API
    static const HdDataSourceLocator &EmptyLocator();

    HD_API
    HdDataSourceLocator();

    HD_API
    explicit HdDataSourceLocator(const TfToken &t1);
    HD_API
    HdDataSourceLocator(const TfToken &t1, const TfToken &t2);
    HD_API
    HdDataSourceLocator(const TfToken &t1, const TfToken &t2, 
                        const TfToken &t3);
    HD_API
    HdDataSourceLocator(const TfToken &t1, const TfToken &t2, const TfToken &t3,
                        const TfToken &t4);
    HD_API
    HdDataSourceLocator(const TfToken &t1, const TfToken &t2, const TfToken &t3,
                        const TfToken &t4, const TfToken &t5);
    HD_API
    HdDataSourceLocator(const TfToken &t1, const TfToken &t2, const TfToken &t3,
                        const TfToken &t4, const TfToken &t5, 
                        const TfToken &t6);

    HD_API
    HdDataSourceLocator(size_t count, const TfToken *tokens);

    HdDataSourceLocator(const HdDataSourceLocator &rhs) = default;

    HD_API 
    size_t GetElementCount() const;

    HD_API
    const TfToken &GetElement(size_t i) const;
 
    HD_API
    const TfToken &GetFirstElement() const;

    HD_API
    const TfToken &GetLastElement() const;

    HD_API
    HdDataSourceLocator ReplaceLastElement(const TfToken &name) const;

    HD_API
    HdDataSourceLocator RemoveLastElement() const;

    HD_API
    HdDataSourceLocator RemoveFirstElement() const;

    HD_API
    HdDataSourceLocator Append(const TfToken &name) const;

    HD_API
    HdDataSourceLocator Append(const HdDataSourceLocator &locator) const;

    HD_API
    HdDataSourceLocator Prepend(const TfToken &name) const;

    HD_API
    HdDataSourceLocator Prepend(const HdDataSourceLocator &locator) const;

    HD_API
    bool HasPrefix(const HdDataSourceLocator &prefix) const;

    HD_API 
    HdDataSourceLocator GetCommonPrefix(const HdDataSourceLocator &other) const;

    HD_API
    HdDataSourceLocator ReplacePrefix(
        const HdDataSourceLocator &oldPrefix,
        const HdDataSourceLocator &newPrefix) const;

    HD_API
    bool Intersects(const HdDataSourceLocator &other) const;

    inline bool operator==(const HdDataSourceLocator &rhs) const {
        return _tokens == rhs._tokens;
    }

    inline bool operator!=(const HdDataSourceLocator &rhs) const {
        return _tokens != rhs._tokens;
    }

    HD_API
    bool operator<(const HdDataSourceLocator &rhs) const;

    inline bool IsEmpty() const {
        return _tokens.empty();
    }

    HD_API
    std::string GetString(const char *delimiter = "/") const;

    template <class HashState>
    friend void TfHashAppend(HashState &h, HdDataSourceLocator const &myObj) {
        h.AppendContiguous(myObj._tokens.data(), myObj._tokens.size());
    }

    inline size_t Hash() const;

private:
    using _TokenVector = TfSmallVector<TfToken, 6>;
    _TokenVector _tokens;
};

inline size_t
HdDataSourceLocator::Hash() const
{
    return TfHash()(*this);
}

//-----------------------------------------------------------------------------

class HdDataSourceLocatorSet
{
private:
    using _Locators = TfSmallVector<HdDataSourceLocator, 8>;
public:
    using const_iterator = typename _Locators::const_iterator;

    explicit HdDataSourceLocatorSet() {}

    HD_API
    HdDataSourceLocatorSet(const HdDataSourceLocator &locator);

    // Initializer list constructor.
    HD_API
    HdDataSourceLocatorSet(
        const std::initializer_list<const HdDataSourceLocator> &l);

    HdDataSourceLocatorSet(const HdDataSourceLocatorSet &rhs) = default;

    HdDataSourceLocatorSet(HdDataSourceLocatorSet &&rhs) = default;

    HdDataSourceLocatorSet &operator=(HdDataSourceLocatorSet &&rhs) = default;

    HdDataSourceLocatorSet &operator=(const HdDataSourceLocatorSet &rhs) 
        = default;

    HD_API
    void insert(const HdDataSourceLocator &locator);

    HD_API
    void insert(const HdDataSourceLocatorSet &locatorSet);

    HD_API
    void append(const HdDataSourceLocator &locator);

    bool operator==(const HdDataSourceLocatorSet &rhs) const {
        return _locators == rhs._locators;
    }

    bool operator!=(const HdDataSourceLocatorSet &rhs) const {
        return !(*this == rhs);
    }

    HD_API
    const_iterator begin() const;
    HD_API
    const_iterator end() const;
    
    HD_API
    bool Intersects(const HdDataSourceLocator &locator) const;

    HD_API
    bool Intersects(const HdDataSourceLocatorSet &locatorSet) const;

    HD_API
    bool IsEmpty() const;

    HD_API
    bool Contains(const HdDataSourceLocator &locator) const;

    HD_API
    HdDataSourceLocatorSet ReplacePrefix(
        const HdDataSourceLocator &oldPrefix,
        const HdDataSourceLocator &newPrefix) const;

private:
    // Sort and uniquify it.
    void _Normalize();

    void _InsertAndDeleteSuffixes(_Locators::iterator *position,
                                  const HdDataSourceLocator &locator);
    // Lexicographically sorted minimal list of locators generating
    // the set.
    _Locators _locators;
};

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_IMAGING_HD_DATASOURCELOCATOR_H