dataSourceLocator.h

//
// Copyright 2021 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/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/staticTokens.h"
#include "pxr/base/tf/hash.h"
 
#include "pxr/imaging/hd/api.h"
 
#include <iosfwd>
 
PXR_NAMESPACE_OPEN_SCOPE
 
#define HD_DATA_SOURCE_LOCATOR_SENTINEL_TOKENS      \
    ((container, "__containerDataSource"))
 
TF_DECLARE_PUBLIC_TOKENS(HdDataSourceLocatorSentinelTokens, HD_API,
                         HD_DATA_SOURCE_LOCATOR_SENTINEL_TOKENS);
 
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);
}
 
HD_API std::ostream& operator<<(std::ostream& out,
    const HdDataSourceLocator &self);
 
//-----------------------------------------------------------------------------
 
class HdDataSourceLocatorSet
{
private:
    using _Locators = TfSmallVector<HdDataSourceLocator, 8>;
public:
    using const_iterator = typename _Locators::const_iterator;
 
    HdDataSourceLocatorSet() {}
 
    HD_API
    static const HdDataSourceLocatorSet &UniversalSet();
 
    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 insert(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;
 
    class IntersectionIterator;
    class IntersectionView;
 
    HD_API
    IntersectionView Intersection(const HdDataSourceLocator &locator) const;
 
private:
    // Sort and uniquify it.
    void _Normalize();
 
    void _InsertAndDeleteSuffixes(_Locators::iterator *position,
                                  const HdDataSourceLocator &locator);
 
    const_iterator _FirstIntersection(const HdDataSourceLocator &locator) const;
 
    // Lexicographically sorted minimal list of locators generating
    // the set.
    _Locators _locators;
};
 
class HdDataSourceLocatorSet::IntersectionIterator
{
public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = const HdDataSourceLocator;
    using reference = value_type&;
    using pointer = value_type*;
    using difference_type = std::ptrdiff_t;
 
    IntersectionIterator()
      : _isFirst(false)
    {
    }
 
    IntersectionIterator(const bool isFirst,
                         const const_iterator &iterator,
                         const const_iterator &end,
                         const HdDataSourceLocator &locator)
      : _isFirst(isFirst)
      , _iterator(iterator)
      , _end(end)
      , _locator(locator)
    {
    }
 
    HD_API
    const HdDataSourceLocator &operator*() const;
 
    const HdDataSourceLocator* operator->() const
    {
        return std::addressof(**this);
    }
 
    HD_API
    IntersectionIterator& operator++();
 
    HD_API
    IntersectionIterator operator++(int);
 
    bool operator==(const IntersectionIterator &other) const noexcept
    {
        return _iterator == other._iterator;
    }
 
    bool operator!=(const IntersectionIterator &other) const noexcept
    {
        return _iterator != other._iterator;
    }
 
private:
    bool _isFirst;
    const_iterator _iterator;
    const_iterator _end;
    HdDataSourceLocator _locator;
};
 
class HdDataSourceLocatorSet::IntersectionView
{
public:
    IntersectionView(const IntersectionIterator &begin,
                     const IntersectionIterator &end)
      : _begin(begin)
      , _end(end)
    {
    }
 
    const IntersectionIterator &begin() const { return _begin; }
 
    const IntersectionIterator &end() const { return _end; }
 
private:
    const IntersectionIterator _begin;
    const IntersectionIterator _end;
};
 
HD_API std::ostream& operator<<(std::ostream& out,
    const HdDataSourceLocatorSet &self);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_IMAGING_HD_DATASOURCELOCATOR_H