IDictionaryCommon.h

Fully qualified name: carb/dictionary/detail/IDictionaryCommon.h

File members: carb/dictionary/detail/IDictionaryCommon.h

// SPDX-FileCopyrightText: Copyright (c) 2025 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
// SPDX-License-Identifier: LicenseRef-NvidiaProprietary
//
// NVIDIA CORPORATION, its affiliates and licensors retain all intellectual
// property and proprietary rights in and to this material, related
// documentation and any modifications thereto. Any use, reproduction,
// disclosure or distribution of this material and related documentation
// without an express license agreement from NVIDIA CORPORATION or
// its affiliates is strictly prohibited.

// purposely missing #pragma once

#ifdef DOXYGEN_BUILD
#    include "../../Defines.h"

namespace carb::dictionary
{
#endif

class ScopedWrite
{
    const IDictionary& m_dictionary;
    Item* m_pItem;

public:
    ScopedWrite(const IDictionary& dictionary, Item* item) : m_dictionary(dictionary), m_pItem(item)
    {
        m_dictionary.writeLock(item);
    }
    ~ScopedWrite()
    {
        m_dictionary.unlock(m_pItem);
    }
    CARB_PREVENT_COPY_AND_MOVE(ScopedWrite);
};

class ScopedRead
{
    const IDictionary& m_dictionary;
    const Item* m_pItem;

public:
    ScopedRead(const IDictionary& dictionary, const Item* item) : m_dictionary(dictionary), m_pItem(item)
    {
        m_dictionary.readLock(item);
    }
    ~ScopedRead()
    {
        m_dictionary.unlock(m_pItem);
    }
    CARB_PREVENT_COPY_AND_MOVE(ScopedRead);
};

inline int32_t IDictionary::getAsInt(const Item* item) CARBLOCAL_CONST
{
    auto val = getAsInt64(item);
    CARB_ASSERT(val >= INT_MIN && val <= INT_MAX);
    return int32_t(val);
}

inline void IDictionary::setInt(Item* item, int32_t value) CARBLOCAL_CONST
{
    setInt64(item, static_cast<int64_t>(value));
}

inline float IDictionary::getAsFloat(const Item* item) CARBLOCAL_CONST
{
    return static_cast<float>(getAsFloat64(item));
}

inline void IDictionary::setFloat(Item* item, float value) CARBLOCAL_CONST
{
    setFloat64(item, static_cast<double>(value));
}

inline int32_t IDictionary::getAsIntAt(const Item* item, size_t index) CARBLOCAL_CONST
{
    auto val = getAsInt64At(item, index);
    CARB_ASSERT(val >= INT_MIN && val <= INT_MAX);
    return int32_t(val);
}

inline void IDictionary::setIntAt(Item* item, size_t index, int32_t value) CARBLOCAL_CONST
{
    setInt64At(item, index, static_cast<int64_t>(value));
}

inline float IDictionary::getAsFloatAt(const Item* item, size_t index) CARBLOCAL_CONST
{
    return static_cast<float>(getAsFloat64At(item, index));
}

inline void IDictionary::setFloatAt(Item* item, size_t index, float value) CARBLOCAL_CONST
{
    setFloat64At(item, index, static_cast<double>(value));
}

#ifndef DOXYGEN_BUILD
template <>
inline bool IDictionary::get<bool>(const Item* item) CARBLOCAL_CONST
{
    return getAsBool(item);
}

template <>
inline int32_t IDictionary::get<int32_t>(const Item* item) CARBLOCAL_CONST
{
    return getAsInt(item);
}

template <>
inline int64_t IDictionary::get<int64_t>(const Item* item) CARBLOCAL_CONST
{
    return getAsInt64(item);
}

template <>
inline float IDictionary::get<float>(const Item* item) CARBLOCAL_CONST
{
    return getAsFloat(item);
}

template <>
inline double IDictionary::get<double>(const Item* item) CARBLOCAL_CONST
{
    return getAsFloat64(item);
}

template <>
inline Int2 IDictionary::get<Int2>(const Item* item) CARBLOCAL_CONST
{
    Int2 value;
    getAsIntArray(item, &value.x, 2);
    return value;
}

template <>
inline Int3 IDictionary::get<Int3>(const Item* item) CARBLOCAL_CONST
{
    Int3 value;
    getAsIntArray(item, &value.x, 3);
    return value;
}

template <>
inline Int4 IDictionary::get<Int4>(const Item* item) CARBLOCAL_CONST
{
    Int4 value;
    getAsIntArray(item, &value.x, 4);
    return value;
}

template <>
inline Uint2 IDictionary::get<Uint2>(const Item* item) CARBLOCAL_CONST
{
    int64_t value[2];
    getAsInt64Array(item, value, 2);
    return { static_cast<uint32_t>(value[0]), static_cast<uint32_t>(value[1]) };
}

template <>
inline Uint3 IDictionary::get<Uint3>(const Item* item) CARBLOCAL_CONST
{
    int64_t value[3];
    getAsInt64Array(item, value, 3);
    return { static_cast<uint32_t>(value[0]), static_cast<uint32_t>(value[1]), static_cast<uint32_t>(value[2]) };
}

template <>
inline Uint4 IDictionary::get<Uint4>(const Item* item) CARBLOCAL_CONST
{
    int64_t value[4];
    getAsInt64Array(item, value, 4);
    return { static_cast<uint32_t>(value[0]), static_cast<uint32_t>(value[1]), static_cast<uint32_t>(value[2]),
             static_cast<uint32_t>(value[3]) };
}

template <>
inline Float2 IDictionary::get<Float2>(const Item* item) CARBLOCAL_CONST
{
    Float2 value;
    getAsFloatArray(item, &value.x, 2);
    return value;
}

template <>
inline Float3 IDictionary::get<Float3>(const Item* item) CARBLOCAL_CONST
{
    Float3 value;
    getAsFloatArray(item, &value.x, 3);
    return value;
}

template <>
inline Float4 IDictionary::get<Float4>(const Item* item) CARBLOCAL_CONST
{
    Float4 value;
    getAsFloatArray(item, &value.x, 4);
    return value;
}

template <>
inline Double2 IDictionary::get<Double2>(const Item* item) CARBLOCAL_CONST
{
    Double2 value;
    getAsFloat64Array(item, &value.x, 2);
    return value;
}

template <>
inline Double3 IDictionary::get<Double3>(const Item* item) CARBLOCAL_CONST
{
    Double3 value;
    getAsFloat64Array(item, &value.x, 3);
    return value;
}

template <>
inline Double4 IDictionary::get<Double4>(const Item* item) CARBLOCAL_CONST
{
    Double4 value;
    getAsFloat64Array(item, &value.x, 4);
    return value;
}

inline void IDictionary::copyItemFlags(Item* dstItem, const Item* srcItem) CARBLOCAL_CONST
{
    setItemFlag(dstItem, ItemFlag::eUnitSubtree, getItemFlag(srcItem, ItemFlag::eUnitSubtree));
}

#endif

#ifdef DOXYGEN_BUILD
} // namespace carb::dictionary
#endif