shaderNodeQuery.h

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
 
#ifndef PXR_USD_SDR_SHADER_NODE_QUERY_H
#define PXR_USD_SDR_SHADER_NODE_QUERY_H
 
#include "pxr/pxr.h"
#include "pxr/usd/sdr/api.h"
#include "pxr/base/tf/type.h"
#include "pxr/base/vt/value.h"
#include "pxr/usd/sdr/shaderNode.h"
 
#include <functional>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class SdrRegistry;
class SdrShaderNodeQueryResult;
 
class SdrShaderNodeQuery {
public:
    typedef std::function<bool (SdrShaderNodeConstPtr)> FilterFn;
 
    SDR_API
    SdrShaderNodeQuery& SelectDistinct(const TfToken& key);
 
    SDR_API
    SdrShaderNodeQuery& SelectDistinct(const std::vector<TfToken>& key);
 
 
    SDR_API
    SdrShaderNodeQuery& NodeValueIs(const TfToken& key, const VtValue& value);
 
    template <typename T>
    SdrShaderNodeQuery& NodeValueIs(const TfToken& key, const T& value) {
        return NodeValueIs(key, VtValue(value));
    }
 
    SDR_API
    SdrShaderNodeQuery& NodeValueIsIn(const TfToken& key,
                                       const std::vector<VtValue>& values);
 
    SDR_API
    SdrShaderNodeQuery& NodeHasValueFor(const TfToken& key);
 
    SDR_API
    SdrShaderNodeQuery& NodeValueIsNot(const TfToken& key, const VtValue& value);
 
    template <typename T>
    SdrShaderNodeQuery& NodeValueIsNot(const TfToken& key, const T& value) {
        return NodeValueIsNot(key, VtValue(value));
    }
 
    SDR_API
    SdrShaderNodeQuery& NodeValueIsNotIn(const TfToken& key,
                                         const std::vector<VtValue>& values);
 
    SDR_API
    SdrShaderNodeQuery& NodeHasNoValueFor(const TfToken& key);
 
 
    SDR_API
    SdrShaderNodeQuery& CustomFilter(FilterFn fn);
 
    SDR_API
    SdrShaderNodeQueryResult Run();
 
private:
    friend class SdrRegistry;
 
    std::vector<std::pair<TfToken, VtValue>> _hasValues;
    std::vector<std::pair<TfToken, std::vector<VtValue>>> _hasOneOfValues;
    std::vector<std::pair<TfToken, VtValue>> _lacksValues;
    std::vector<std::pair<TfToken, std::vector<VtValue>>> _lacksAllOfValues;
    std::vector<TfToken> _selectKeys;
    std::vector<FilterFn> _customFilters;
};
 
class SdrShaderNodeQueryResult {
public:
    const TfTokenVector& GetKeys() const & { return _keys; }
 
    TfTokenVector GetKeys() && { return std::move(_keys); }
 
    const std::vector<std::vector<VtValue>>& GetValues() const & { return _values; }
 
    std::vector<std::vector<VtValue>> GetValues() && {
        return std::move(_values);
    }
 
    template <class T>
    std::vector<std::vector<T>> GetValuesAs() const {
        std::vector<std::vector<T>> result;
        result.reserve(_values.size());
        for (const std::vector<VtValue>& row : _values) {
            std::vector<T> convertedRows;
            convertedRows.reserve(row.size());
            for (const VtValue& value : row) {
                const VtValue convertedValue = VtValue::Cast<T>(value);
                if (convertedValue.IsEmpty()) {
                    TF_CODING_ERROR(
                        "Failed to get value of type %s from value '%s'",
                        typeid(T).name(), TfStringify(value).c_str());
                    return {};
                } else {
                    convertedRows.push_back(convertedValue);
                }
            result.push_back(convertedRows);
            }
        }
        return result;
    }
 
    SDR_API
    std::vector<std::vector<std::string>> GetStringifiedValues() const;
 
    SDR_API
    std::vector<SdrShaderNodePtrVec> GetShaderNodesByValues() const;
 
    SDR_API
    SdrShaderNodePtrVec GetAllShaderNodes() const;
 
private:
    friend class SdrRegistry;
 
    bool _IsValid() const;
 
    std::vector<TfToken> _keys;
    std::vector<std::vector<VtValue>> _values;
    std::vector<SdrShaderNodePtrVec> _nodes;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_SDR_SHADER_NODE_QUERY_H