annotation_wrapper.h

Go to the documentation of this file.

/***************************************************************************************************
 * Copyright 2026 NVIDIA Corporation. All rights reserved.
 **************************************************************************************************/
 
#ifndef MI_NEURAYLIB_ANNOTATION_WRAPPER_H
#define MI_NEURAYLIB_ANNOTATION_WRAPPER_H
 
#include <mi/base/handle.h>
#include <mi/neuraylib/assert.h>
#include <mi/neuraylib/iexpression.h>
#include <mi/neuraylib/ifunction_call.h>
#include <mi/neuraylib/imaterial_instance.h>
#include <mi/neuraylib/imdl_factory.h>
#include <mi/neuraylib/itransaction.h>
#include <mi/neuraylib/itype.h>
#include <mi/neuraylib/ivalue.h>
 
namespace mi {
 
namespace neuraylib {
 
class Annotation_wrapper
{
public:
 
 
 
    Annotation_wrapper(const mi::neuraylib::IAnnotation_block* anno_block);
 
    mi::Size get_annotation_count() const;
 
    const char* get_annotation_name(mi::Size anno_index) const;
 
    mi::Size get_annotation_index(
        const char* anno_name,
        mi::Size offset = 0) const;
 
    mi::Size get_annotation_param_count(mi::Size anno_index) const;
 
    const char* get_annotation_param_name(mi::Size anno_index, mi::Size param_index) const;
 
    const IType* get_annotation_param_type(mi::Size anno_index, mi::Size param_index) const;
 
    const IValue* get_annotation_param_value(
        mi::Size anno_index, mi::Size param_index) const;
 
    const IValue* get_annotation_param_value_by_name(
        const char* anno_name, mi::Size param_index ) const;
 
    template <class T>
    mi::Sint32 get_annotation_param_value(
        mi::Size anno_index, mi::Size param_index, T& value) const;
 
    template <class T>
    mi::Sint32 get_annotation_param_value_by_name(
        const char* anno_name, mi::Size param_index, T& value ) const;
 
private:
    mi::base::Handle<const mi::neuraylib::IAnnotation_block> m_anno_block;
};
 // end group mi_neuray_mdl_elements
 
inline Annotation_wrapper::Annotation_wrapper(
    const mi::neuraylib::IAnnotation_block* anno_block)
{
    // anno_block == null is valid and will result in an annotation count of zero
    m_anno_block = make_handle_dup(anno_block);
}
 
inline mi::Size Annotation_wrapper::get_annotation_count() const
{
    if (!m_anno_block)
        return 0;
 
    return m_anno_block->get_size();
}
 
inline const char* Annotation_wrapper::get_annotation_name(mi::Size anno_index) const
{
    if (!m_anno_block || m_anno_block->get_size() <= anno_index)
        return nullptr;
 
    mi::base::Handle<const mi::neuraylib::IAnnotation> anno(
        m_anno_block->get_annotation(anno_index));
    if (!anno)
        return nullptr;
 
    return anno->get_name();
}
 
inline mi::Size Annotation_wrapper::get_annotation_index(
    const char* anno_name,
    mi::Size offset) const
{
    if (!anno_name || !m_anno_block)
        return static_cast<mi::Size>(-1);
 
    for (mi::Size i = offset, n = get_annotation_count(); i < n; ++i) {
        const char* s = get_annotation_name(i);
        if (s && strcmp(anno_name, s) == 0)
            return i;
    }
 
    return static_cast<mi::Size>(-1);
}
 
inline mi::Size Annotation_wrapper::get_annotation_param_count(mi::Size anno_index) const
{
    if (!m_anno_block || m_anno_block->get_size() <= anno_index)
        return 0;
 
    mi::base::Handle<const mi::neuraylib::IAnnotation> anno(
        m_anno_block->get_annotation(anno_index));
    if (!anno)
        return 0;
 
    mi::base::Handle<const mi::neuraylib::IExpression_list> expr_list(anno->get_arguments());
    if (!expr_list)
        return 0;
 
    return expr_list->get_size();
}
 
inline const char* Annotation_wrapper::get_annotation_param_name(
    mi::Size anno_index, mi::Size param_index) const
{
    if (!m_anno_block || m_anno_block->get_size() <= anno_index)
        return nullptr;
 
    mi::base::Handle<const mi::neuraylib::IAnnotation> anno(
        m_anno_block->get_annotation(anno_index));
    if (!anno)
        return nullptr;
 
    mi::base::Handle<const mi::neuraylib::IExpression_list> expr_list(anno->get_arguments());
    if (!expr_list)
        return nullptr;
 
    if (expr_list->get_size() <= param_index)
        return nullptr;
 
    return expr_list->get_name(param_index);
}
 
inline const IType* Annotation_wrapper::get_annotation_param_type(
    mi::Size anno_index, mi::Size param_index) const
{
    if (!m_anno_block || m_anno_block->get_size() <= anno_index)
        return nullptr;
 
    mi::base::Handle<const mi::neuraylib::IAnnotation> anno(
        m_anno_block->get_annotation(anno_index));
    if (!anno)
        return nullptr;
 
    mi::base::Handle<const mi::neuraylib::IExpression_list> expr_list(anno->get_arguments());
    if (!expr_list)
        return nullptr;
 
    if (expr_list->get_size() <= param_index)
        return nullptr;
 
    mi::base::Handle<const mi::neuraylib::IExpression> expr(expr_list->get_expression(param_index));
    if (!expr)
        return nullptr;
 
    return expr->get_type();
}
 
inline const mi::neuraylib::IValue* Annotation_wrapper::get_annotation_param_value(
    mi::Size anno_index, mi::Size param_index) const
{
    if (!m_anno_block || m_anno_block->get_size() <= anno_index)
        return nullptr;
 
    mi::base::Handle<const mi::neuraylib::IAnnotation> anno(
        m_anno_block->get_annotation(anno_index));
    if (!anno)
        return nullptr;
 
    mi::base::Handle<const mi::neuraylib::IExpression_list> expr_list(anno->get_arguments());
    if (!expr_list)
        return nullptr;
 
    if (expr_list->get_size() <= param_index)
        return nullptr;
 
    mi::base::Handle<const mi::neuraylib::IExpression> expr(expr_list->get_expression(param_index));
    if (!expr)
        return nullptr;
 
    mi::base::Handle<const mi::neuraylib::IExpression_constant> c(
        expr->get_interface<const mi::neuraylib::IExpression_constant>());
    if (!c)
        return nullptr;
 
    return c->get_value();
}
 
inline const mi::neuraylib::IValue* Annotation_wrapper::get_annotation_param_value_by_name(
    const char* anno_name, mi::Size param_index) const
{
    mi::Size anno_index = get_annotation_index(anno_name);
    if (anno_index == static_cast<mi::Size>(-1))
        return nullptr;
 
    return get_annotation_param_value(anno_index, param_index);
}
 
template <class T>
inline mi::Sint32 Annotation_wrapper::get_annotation_param_value(
    mi::Size anno_index, mi::Size param_index, T& value) const
{
    mi::base::Handle<const mi::neuraylib::IValue> v(get_annotation_param_value(
        anno_index, param_index));
    if (!v)
        return -3;
 
    return mi::neuraylib::get_value(v.get(), value);
}
 
template <class T>
inline mi::Sint32 Annotation_wrapper::get_annotation_param_value_by_name(
    const char* anno_name, mi::Size param_index, T& value) const
{
    mi::base::Handle<const mi::neuraylib::IValue> v(get_annotation_param_value_by_name(
        anno_name, param_index));
    if (!v)
        return -3;
 
    return mi::neuraylib::get_value(v.get(), value);
}
 
} // namespace neuraylib
 
} // namespace mi
 
#endif // MI_NEURAYLIB_ANNOTATION_WRAPPER_H