request.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_REQUEST_H
#define PXR_EXEC_VDF_REQUEST_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/vdf/api.h"
#include "pxr/exec/vdf/maskedOutput.h"
#include "pxr/exec/vdf/maskedOutputVector.h"
 
#include "pxr/base/tf/bits.h"
#include "pxr/base/tf/hash.h"
 
#include <cstddef>
#include <iterator>
#include <memory>
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class VdfNetwork;
 
class VdfRequest 
{
public:
    VDF_API
    VdfRequest();
 
    VDF_API
    explicit VdfRequest(const VdfMaskedOutput& output);
 
    VDF_API
    explicit VdfRequest(const VdfMaskedOutputVector& vector);
 
    VDF_API
    explicit VdfRequest(VdfMaskedOutputVector&& vector);
 
    VDF_API
    ~VdfRequest();
 
    // Queries
 
    VDF_API
    bool IsEmpty() const;
 
    VDF_API
    size_t GetSize() const;
 
    VDF_API
    const VdfNetwork* GetNetwork() const;
 
    // Iterators
 
    class const_iterator
    {
    public:
        using iterator_category = std::forward_iterator_tag;
        using value_type = const VdfMaskedOutput;
        using reference = const VdfMaskedOutput &;
        using pointer = const VdfMaskedOutput *;
        using difference_type = std::ptrdiff_t;
 
        VDF_API
        const_iterator();
 
        reference operator*() const { return _Dereference(); }
        pointer operator->() const { return &(_Dereference()); }
 
        const_iterator &operator++() {
            _Increment();
            return *this;
        }
 
        const_iterator operator++(int) {
            const_iterator r(*this);
            _Increment();
            return r;
        }
 
        bool operator==(const const_iterator& rhs) const {
            return _Equal(rhs);
        }
 
        bool operator!=(const const_iterator& rhs) const {
            return !_Equal(rhs);
        }
 
    private:
        friend class VdfRequest;
 
        VDF_API
        const_iterator(
            const VdfMaskedOutput* mo,
            const VdfMaskedOutput* first,
            const TfBits* bits);
 
        VDF_API
        void _Increment();
 
        bool _Equal(const const_iterator& rhs) const {
            return _mo == rhs._mo;
        }
 
        const VdfMaskedOutput& _Dereference() const {
            return *_mo;
        }
 
        VDF_API
        size_t _ComputeIndex() const;
 
        // Data members
        const VdfMaskedOutput *_mo;
        const VdfMaskedOutput *_firstMo;
        const TfBits *_bits;
    };
 
    VDF_API
    const_iterator begin() const;
 
    VDF_API
    const_iterator end() const;
 
    // Random access using integer indices
 
    class IndexedView
    {
    public:
        IndexedView(const VdfRequest &request) : _r(&request) {}
 
        size_t GetSize() const {
            return _r->_request->size();
        }
 
        const VdfMaskedOutput *Get(const size_t i) const {
            return !_r->_bits.GetSize() || _r->_bits.IsSet(i)
                ? &(*_r->_request)[i]
                : nullptr;
        }
 
    private:
        const VdfRequest *_r;
    };
 
    // Request subset operators
 
    VDF_API
    void Add(const const_iterator& iterator);
 
    VDF_API
    void Remove(const const_iterator& iterator);
 
    VDF_API
    void AddAll();
 
    VDF_API
    void RemoveAll();
 
    friend bool operator==(const VdfRequest& lhs, const VdfRequest& rhs)
    {
        return (lhs._request == rhs._request || 
            *lhs._request == *rhs._request) &&
            lhs._bits == rhs._bits;
    }
 
    friend bool operator!=(const VdfRequest& lhs, const VdfRequest& rhs)
    {
        return !(lhs == rhs);
    }
 
    struct Hash {
        size_t operator()(const VdfRequest &request) const
        {
            size_t hash = TfBits::Hash()(request._bits);
 
            // Instead of hashing on the complete request we just do it on the
            // first three outputs (if any).
            const size_t num = std::min<size_t>(request.GetSize(), 3);
 
            const VdfMaskedOutputVector &outputs = *request._request;
            for(size_t i = 0; i < num; i++) {
                hash = TfHash::Combine(
                    hash, VdfMaskedOutput::Hash()(outputs[i]));
            }
 
            // Also add the last entry.
            if (request.GetSize() > 3) {
                hash = TfHash::Combine(
                    hash, VdfMaskedOutput::Hash()(outputs.back()));
            }
 
            return hash;
        }
    };
 
private:
    void _Add(size_t index);
 
    void _Remove(size_t index);
 
private:
    // Internally held vector that is guaranteed to be sorted and uniqued.
    std::shared_ptr<const VdfMaskedOutputVector> _request;
 
    // Used for holding "subsets" without changing the vector.  
    // An empty bit set is a sentinel for a full vector (i.e. all the elements
    // in the internally held vector are part of the request). This bit set
    // should only ever be of size 0 or the size of the vector.
    //
    TfBits _bits;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif