attributeLimits.h

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
 
#ifndef PXR_USD_USD_ATTRIBUTE_LIMITS_H
#define PXR_USD_USD_ATTRIBUTE_LIMITS_H
 
#include "pxr/usd/usd/attribute.h"
 
#include "pxr/base/tf/staticTokens.h"
#include "pxr/base/tf/token.h"
#include "pxr/base/vt/value.h"
 
#include <optional>
#include <string>
 
PXR_NAMESPACE_OPEN_SCOPE
 
#define USD_LIMITS_KEYS                 \
    ((Soft,         "soft"))            \
    ((Hard,         "hard"))            \
    ((Minimum,      "minimum"))         \
    ((Maximum,      "maximum"))
 
TF_DECLARE_PUBLIC_TOKENS(
    UsdLimitsKeys, USD_API, USD_LIMITS_KEYS);
 
class UsdAttributeLimits
{
public:
    UsdAttributeLimits() = default;
 
    USD_API
    UsdAttributeLimits(
        const UsdAttribute& attr,
        const TfToken& subDictKey);
 
 
    USD_API
    bool IsValid() const;
 
    USD_API
    UsdAttribute GetAttribute() const;
 
    USD_API
    TfToken GetSubDictKey() const;
 
 
 
    USD_API
    bool HasAuthored() const;
 
    USD_API
    bool Clear();
 
    USD_API
    bool HasAuthored(const TfToken& key) const;
 
    USD_API
    bool Clear(const TfToken& key);
 
    USD_API
    bool HasAuthoredMinimum() const;
 
    USD_API
    bool ClearMinimum();
 
    USD_API
    bool HasAuthoredMaximum() const;
 
    USD_API
    bool ClearMaximum();
 
 
 
    class ValidationResult
    {
    public:
        ValidationResult() = default;
 
        bool Success() const {
            return _success;
        }
 
        const VtDictionary& GetInvalidValuesDict() const {
            return _invalidValuesDict;
        }
 
        const VtDictionary& GetConformedSubDict() const {
            return _conformedSubDict;
        }
 
        USD_API
        std::string GetErrorString() const;
 
        explicit operator bool() const {
            return Success();
        }
 
        bool operator==(const ValidationResult& rhs) const {
            return _success == rhs._success &&
                   _invalidValuesDict == rhs._invalidValuesDict &&
                   _conformedSubDict == rhs._conformedSubDict &&
                   _attrPath == rhs._attrPath &&
                   _attrTypeName == rhs._attrTypeName;
        }
 
        bool operator!=(const ValidationResult& rhs) const {
            return !(*this == rhs);
        }
 
    private:
        friend class UsdAttributeLimits;
        ValidationResult(
            bool success,
            const VtDictionary& invalidValuesDict,
            const VtDictionary& conformedSubDict,
            const SdfPath& attrPath,
            const std::string& attrTypeName)
            : _success(success),
              _invalidValuesDict(invalidValuesDict),
              _conformedSubDict(conformedSubDict),
              _attrPath(attrPath),
              _attrTypeName(attrTypeName) {}
 
    private:
        bool _success = false;
        VtDictionary _invalidValuesDict;
        VtDictionary _conformedSubDict;
        SdfPath _attrPath;
        std::string _attrTypeName;
    };
 
    //
    USD_API
    bool Validate(
        const VtDictionary& subDict,
        ValidationResult* result = nullptr) const;
 
    USD_API
    bool Set(const VtDictionary& subDict);
 
 
 
    template <typename T>
    std::optional<T> Get(const TfToken& key) const;
 
    template <typename T>
    T GetOr(const TfToken& key, const T& defaultValue) const;
 
    template <typename T>
    bool Set(const TfToken& key, const T& value);
 
    template <typename T>
    std::optional<T> GetMinimum() const;
 
    template <typename T>
    T GetMinimumOr(const T& defaultValue) const;
 
    template <typename T>
    bool SetMinimum(const T& value);
 
    template <typename T>
    std::optional<T> GetMaximum() const;
 
    template <typename T>
    T GetMaximumOr(const T& defaultValue) const;
 
    template <typename T>
    bool SetMaximum(const T& value);
 
 
 
    USD_API
    VtValue Get(const TfToken& key) const;
 
    USD_API
    bool Set(const TfToken& key, const VtValue& value);
 
    USD_API
    VtValue GetMinimum() const;
 
    USD_API
    bool SetMinimum(const VtValue& value);
 
    USD_API
    VtValue GetMaximum() const;
 
    USD_API
    bool SetMaximum(const VtValue& value);
 
 
    explicit operator bool() const {
        return IsValid();
    }
 
    bool operator==(const UsdAttributeLimits& rhs) const {
        return _attr == rhs._attr && _subDictKey == rhs._subDictKey;
    }
 
    bool operator!=(const UsdAttributeLimits& rhs) const {
        return !(*this == rhs);
    }
 
private:
    USD_API
    static TfToken _MakeKeyPath(const TfToken&, const TfToken&);
 
private:
    UsdAttribute _attr;
    TfToken _subDictKey;
};
 
template <typename T>
inline std::optional<T>
UsdAttributeLimits::Get(const TfToken& key) const
{
    if (!IsValid() || key.IsEmpty()) {
        return {};
    }
 
    T value;
    if (_attr.GetMetadataByDictKey(
            SdfFieldKeys->Limits,
            _MakeKeyPath(_subDictKey, key),
            &value)) {
        return value;
    }
    return {};
}
 
template <typename T>
inline T
UsdAttributeLimits::GetOr(
    const TfToken& key,
    const T& defaultValue) const
{
    if (!IsValid() || key.IsEmpty()) {
        return defaultValue;
    }
 
    T value;
    if (_attr.GetMetadataByDictKey(
            SdfFieldKeys->Limits,
            _MakeKeyPath(_subDictKey, key),
            &value)) {
        return value;
    }
    return defaultValue;
}
 
template <typename T>
inline bool
UsdAttributeLimits::Set(
    const TfToken& key,
    const T& value)
{
    return Set(key, VtValue(value));
}
 
template <typename T>
inline std::optional<T>
UsdAttributeLimits::GetMinimum() const
{
    return Get<T>(UsdLimitsKeys->Minimum);
}
 
template <typename T>
inline T
UsdAttributeLimits::GetMinimumOr(const T& defaultValue) const
{
    return GetOr<T>(UsdLimitsKeys->Minimum, defaultValue);
}
 
template <typename T>
inline bool
UsdAttributeLimits::SetMinimum(const T& value)
{
    return Set(UsdLimitsKeys->Minimum, value);
}
 
template <typename T>
inline std::optional<T>
UsdAttributeLimits::GetMaximum() const
{
    return Get<T>(UsdLimitsKeys->Maximum);
}
 
template <typename T>
inline T
UsdAttributeLimits::GetMaximumOr(const T& defaultValue) const
{
    return GetOr<T>(UsdLimitsKeys->Maximum, defaultValue);
}
 
template <typename T>
inline bool
UsdAttributeLimits::SetMaximum(const T& value)
{
    return Set(UsdLimitsKeys->Maximum, value);
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif