connectorMap.h

Go to the documentation of this file.

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_EXEC_VDF_CONNECTOR_MAP_H
#define PXR_EXEC_VDF_CONNECTOR_MAP_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/base/tf/smallVector.h"
#include "pxr/base/tf/token.h"
 
#include <iterator>
#include <utility>
 
PXR_NAMESPACE_OPEN_SCOPE
 
template <typename Connector>
class VdfConnectorMap
{
private:
    using _Pair = std::pair<TfToken, Connector*>;
    using _Vector = TfSmallVector<_Pair, 1>;
 
public:
    using key_type = TfToken;
    using mapped_type = Connector*;
    using value_type = _Pair;
    using pointer = _Pair*;
    using reference = _Pair&;
    using const_reference = const _Pair&;
    using size_type = typename _Vector::size_type;
    using difference_type = typename _Vector::difference_type;
    using iterator = typename _Vector::const_iterator;
    using reverse_iterator = typename _Vector::const_reverse_iterator;
    using const_iterator = typename _Vector::const_iterator;
    using const_reverse_iterator = typename _Vector::const_reverse_iterator;
 
 
    VdfConnectorMap() = default;
 
    explicit VdfConnectorMap(size_t n) {
        _vec.reserve(n);
    }
 
    ~VdfConnectorMap() {
        clear();
    }
 
    const_iterator begin() const {
        return _vec.begin();
    }
 
    const_iterator end() const {
        return _vec.end();
    }
 
    const_reverse_iterator rbegin() const {
        return _vec.rbegin();
    }
 
    const_reverse_iterator rend() const {
        return _vec.rend();
    }
 
    size_type size() const {
        return _vec.size();
    }
 
    bool empty() const {
        return _vec.empty();
    }
 
    void swap(VdfConnectorMap& x) {
        _vec.swap(x._vec);
    }
 
    friend void swap(VdfConnectorMap& lhs, VdfConnectorMap& rhs) {
        lhs.swap(rhs);
    }
 
    void clear();
 
    const_iterator find(const key_type& k) const;
 
    bool operator==(const VdfConnectorMap& x) const {
        return _vec == x._vec;
    }
 
    bool operator!=(const VdfConnectorMap& x) const {
        return _vec != x._vec;
    }
 
    template <typename... Args>
    std::pair<const_iterator, bool>
    try_emplace(const key_type& k, Args&&... args);
 
private:
 
    _Vector _vec;
};
 
 
template <typename Connector>
typename VdfConnectorMap<Connector>::const_iterator
VdfConnectorMap<Connector>::find(const key_type& k) const
{
    const const_iterator endIter = end();
    for (const_iterator i = begin(); i != endIter; ++i) {
        if (i->first == k) {
            return i;
        }
    }
 
    return endIter;
}
 
template <typename Connector>
template <typename... Args>
std::pair<typename VdfConnectorMap<Connector>::const_iterator, bool> 
VdfConnectorMap<Connector>::try_emplace(const key_type& k, Args&&... args)
{
    if (const const_iterator i = find(k); i != end()) {
        return {i, false};
    }
 
    _vec.emplace_back(k, new Connector(std::forward<Args>(args)...));
    return {std::prev(end()), true};
}
 
template <typename Connector>
void
VdfConnectorMap<Connector>::clear()
{
    for (const auto &[_, connector] : _vec) {
        delete connector;
    }
    _vec.clear();
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif