set_get.h

Go to the documentation of this file.

/***************************************************************************************************
 * Copyright 2024 NVIDIA Corporation. All rights reserved.
 **************************************************************************************************/
 
#ifndef MI_NEURAYLIB_SET_GET_H
#define MI_NEURAYLIB_SET_GET_H
 
#include <mi/base/config.h>
#include <mi/base/handle.h>
#include <mi/neuraylib/iarray.h>
#include <mi/neuraylib/iattribute_set.h>
#include <mi/neuraylib/ibbox.h>
#include <mi/neuraylib/icolor.h>
#include <mi/neuraylib/idynamic_array.h>
#include <mi/neuraylib/ienum.h>
#include <mi/neuraylib/imatrix.h>
#include <mi/neuraylib/inumber.h>
#include <mi/neuraylib/iref.h>
#include <mi/neuraylib/ispectrum.h>
#include <mi/neuraylib/istring.h>
#include <mi/neuraylib/iuuid.h>
#include <mi/neuraylib/ivector.h>
#include <mi/neuraylib/type_traits.h>
 
#include <string>
#include <vector>
 
namespace mi {
 
template<class T>
mi::Sint32 set_value( mi::IData* data, const T& value)
{
    mi::base::Handle<mi::INumber> v( data->get_interface<mi::INumber>());
    if( v) {
        v->set_value( value);
        return 0;
    }
    mi::base::Handle<mi::IEnum> e( data->get_interface<mi::IEnum>());
    if( e) {
        mi::Sint32 result = e->set_value( static_cast<mi::Sint32>( value));
        return result == 0 ? 0 : -2;
    }
    return -1;
}
 
inline mi::Sint32 set_value( mi::IData* data, const char* value)
{
    mi::base::Handle<mi::IString> s( data->get_interface<mi::IString>());
    if( s) {
        s->set_c_str( value);
        return 0;
    }
    mi::base::Handle<mi::IRef> r( data->get_interface<mi::IRef>());
    if( r) {
        mi::Sint32 result = r->set_reference( value);
        return result == 0 ? 0 : -2;
    }
    mi::base::Handle<mi::IEnum> e( data->get_interface<mi::IEnum>());
    if( e) {
        mi::Sint32 result = e->set_value_by_name( value);
        return result == 0 ? 0 : -2;
    }
    return -1;
}
 
inline mi::Sint32 set_value( mi::IData* data, const std::string& value)
{
    return set_value( data, value.c_str());
}
 
inline mi::Sint32 set_value( mi::IData* data, const mi::base::Uuid& value)
{
    mi::base::Handle<mi::IUuid> u( data->get_interface<mi::IUuid>());
    if( u) {
        u->set_uuid( value);
        return 0;
    }
    return -1;
}
 
template <class T, Size DIM>
inline mi::Sint32 set_value( mi::IData* data, const mi::math::Vector<T,DIM>& value)
{
    typedef typename mi::Vector_type_traits<T,DIM>::Interface_type Vector_interface_type;
    mi::base::Handle<Vector_interface_type> v( data->get_interface<Vector_interface_type>());
    if( v) {
        v->set_value( value);
        return 0;
    }
    return -1;
}
 
template <class T, Size ROW, Size COL>
mi::Sint32 set_value( mi::IData* data, const mi::math::Matrix<T,ROW,COL>& value)
{
    typedef typename mi::Matrix_type_traits<T,ROW,COL>::Interface_type Matrix_interface_type;
    mi::base::Handle<Matrix_interface_type> m( data->get_interface<Matrix_interface_type>());
    if( m) {
        m->set_value( value);
        return 0;
    }
    return -1;
}
 
inline mi::Sint32 set_value( mi::IData* data, const mi::Color& value)
{
    mi::base::Handle<mi::IColor> c( data->get_interface<mi::IColor>());
    if( c) {
        c->set_value( value);
        return 0;
    }
    mi::base::Handle<mi::IColor3> c3( data->get_interface<mi::IColor3>());
    if( c3) {
        c3->set_value( value);
        return 0;
    }
    return -1;
}
 
inline mi::Sint32 set_value( mi::IData* data, const mi::Spectrum& value)
{
    mi::base::Handle<mi::ISpectrum> s( data->get_interface<mi::ISpectrum>());
    if( s) {
        s->set_value( value);
        return 0;
    }
    return -1;
}
 
inline mi::Sint32 set_value( mi::IData* data, const mi::Bbox3& value)
{
    mi::base::Handle<mi::IBbox3> b( data->get_interface<mi::IBbox3>());
    if( b) {
        b->set_value( value);
        return 0;
    }
    return -1;
}
 
template<class T>
mi::Sint32 set_value( mi::IData* data, mi::Size index, const T& value)
{
    mi::base::Handle<mi::IData_collection> c( data->get_interface<mi::IData_collection>());
    if( c) {
        mi::base::Handle<mi::IData> d( c->get_value<mi::IData>( index));
        if( !d)
            return -3;
        return set_value( d.get(), value);
    }
    return -1;
}
 
template<class T>
mi::Sint32 set_value( mi::IData* data, const char* key, const T& value)
{
    mi::base::Handle<mi::IData_collection> c( data->get_interface<mi::IData_collection>());
    if( c) {
        mi::base::Handle<mi::IData> d( c->get_value<mi::IData>( key));
        if( !d)
            return -3;
        return set_value( d.get(), value);
    }
    return -1;
}
 
template<class T>
mi::Sint32 set_value( mi::IData* data, const T* values, mi::Size n)
{
    mi::base::Handle<mi::IArray> a( data->get_interface<mi::IArray>());
    if( a) {
 
        mi::base::Handle<mi::IDynamic_array> da( data->get_interface<mi::IDynamic_array>());
        if( da)
            da->set_length( n);
        else if( a->get_length() != n)
            return -5;
 
        for( mi::Size i = 0; i < n; ++i) {
            mi::base::Handle<mi::IData> d( a->get_element<mi::IData>( i));
            if( !d)
                return -1;
            mi::Sint32 result = set_value( d.get(), values[i]);
            if( result != 0)
                return result;
        }
        return 0;
    }
 
    return -1;
}
 
template<class T>
mi::Sint32 set_value( mi::IData* data, const std::vector<T>& values)
{
    return set_value( data, values.data(), static_cast<mi::Size>( values.size()));
}
 
template<class T>
mi::Sint32 get_value( const mi::IData* data, T& value)
{
    mi::base::Handle<const mi::INumber> v( data->get_interface<mi::INumber>());
    if( v) {
        v->get_value( value);
        return 0;
    }
// disable C4800: 'mi::Sint32' : forcing value to bool 'true' or 'false' (performance warning)
// disable C4800: 'mi::Uint32' : forcing value to bool 'true' or 'false' (performance warning)
#ifdef MI_COMPILER_MSC
#pragma warning( push )
#pragma warning( disable : 4800 )
#endif
    mi::base::Handle<const mi::IEnum> e( data->get_interface<mi::IEnum>());
    if( e) {
        value = static_cast<T>( e->get_value());
        return 0;
    }
#ifdef MI_COMPILER_MSC
#pragma warning( pop )
#endif
    return -1;
}
 
inline mi::Sint32 get_value( const mi::IData* data, const char*& value)
{
    mi::base::Handle<const mi::IString> i( data->get_interface<mi::IString>());
    if( i) {
        value = i->get_c_str();
        return 0;
    }
    mi::base::Handle<const mi::IRef> r( data->get_interface<mi::IRef>());
    if( r) {
        value = r->get_reference_name();
        return 0;
    }
    mi::base::Handle<const mi::IEnum> e( data->get_interface<mi::IEnum>());
    if( e) {
        value = e->get_value_by_name();
        return 0;
    }
    return -1;
}
 
inline mi::Sint32 get_value( const mi::IData* data, mi::base::Uuid& value)
{
    mi::base::Handle<const mi::IUuid> u( data->get_interface<mi::IUuid>());
    if( u) {
        value = u->get_uuid();
        return 0;
    }
    return -1;
}
 
template <class T, Size DIM>
inline mi::Sint32 get_value( const mi::IData* data, mi::math::Vector<T,DIM>& value)
{
    typedef typename mi::Vector_type_traits<T,DIM>::Interface_type Vector_interface_type;
    mi::base::Handle<const Vector_interface_type> v( data->get_interface<Vector_interface_type>());
    if( v) {
        value = v->get_value();
        return 0;
    }
    return -1;
}
 
template <class T, Size ROW, Size COL>
mi::Sint32 get_value( const mi::IData* data, mi::math::Matrix<T,ROW,COL>& value)
{
    typedef typename mi::Matrix_type_traits<T,ROW,COL>::Interface_type Matrix_interface_type;
    mi::base::Handle<const Matrix_interface_type> m( data->get_interface<Matrix_interface_type>());
    if( m) {
        value = m->get_value();
        return 0;
    }
    return -1;
}
 
inline mi::Sint32 get_value( const mi::IData* data, mi::Color& value)
{
    mi::base::Handle<const mi::IColor> c( data->get_interface<mi::IColor>());
    if( c) {
        value = c->get_value();
        return 0;
    }
    mi::base::Handle<const mi::IColor3> c3( data->get_interface<mi::IColor3>());
    if( c3) {
        value = c3->get_value();
        return 0;
    }
    return -1;
}
 
inline mi::Sint32 get_value( const mi::IData* data, mi::Spectrum& value)
{
    mi::base::Handle<const mi::ISpectrum> s( data->get_interface<mi::ISpectrum>());
    if( s) {
        value = s->get_value();
        return 0;
    }
    return -1;
}
 
inline mi::Sint32 get_value( const mi::IData* data, mi::Bbox3& value)
{
    mi::base::Handle<const mi::IBbox3> b( data->get_interface<mi::IBbox3>());
    if( b) {
        value = b->get_value();
        return 0;
    }
    return -1;
}
 
template<class T>
mi::Sint32 get_value( const mi::IData* data, mi::Size index, T& value)
{
    mi::base::Handle<const mi::IData_collection> c( data->get_interface<mi::IData_collection>());
    if( c) {
        mi::base::Handle<const mi::IData> d( c->get_value<mi::IData>( index));
        if( !d)
            return -3;
        return get_value( d.get(), value);
    }
    return -1;
}
 
template<class T>
mi::Sint32 get_value( const mi::IData* data, const char* key, T& value)
{
    mi::base::Handle<const mi::IData_collection> c( data->get_interface<mi::IData_collection>());
    if( c) {
        mi::base::Handle<const mi::IData> d( c->get_value<mi::IData>( key));
        if( !d)
            return -3;
        return get_value( d.get(), value);
    }
    return -1;
}
 
template<class T>
mi::Sint32 get_value( const mi::IData* data, T* values, mi::Size n)
{
    mi::base::Handle<const mi::IArray> a( data->get_interface<mi::IArray>());
    if( a) {
 
        if( a->get_length() != n)
            return -5;
 
        for( mi::Size i = 0; i < n; ++i) {
            mi::base::Handle<const mi::IData> d( a->get_element<mi::IData>( i));
            if( !d)
                return -1;
            mi::Sint32 result = get_value( d.get(), values[i]);
            if( result != 0)
                return result;
        }
        return 0;
    }
 
    return -1;
}
 
template<class T>
mi::Sint32 get_value( const mi::IData* data, std::vector<T>& values)
{
    mi::base::Handle<const mi::IArray> a( data->get_interface<mi::IArray>());
    if( a)
        values.resize( a->get_length());
 
    return get_value( data, values.data(), static_cast<mi::Size>( values.size()));
}
 
inline mi::Sint32 get_value( const mi::IData* data, std::string& value)
{
    const char* c_str = 0;
    const mi::Sint32 res = get_value( data, c_str);
    if( c_str)
        value.assign( c_str);
    return res;
}
 // end group mi_neuray_types
 
template<class T>
mi::Sint32 set_value(
    mi::neuraylib::IAttribute_set* attribute_set, const char* name, const T& value)
{
    mi::base::Handle<mi::IData> data( attribute_set->edit_attribute<mi::IData>( name));
    if( !data)
        return -4;
    return set_value( data.get(), value);
}
 
template<class T>
mi::Sint32 set_value(
    mi::neuraylib::IAttribute_set* attribute_set, const char* name, mi::Size index, const T& value)
{
    mi::base::Handle<mi::IData> data( attribute_set->edit_attribute<mi::IData>( name));
    if( !data)
        return -4;
    return set_value( data.get(), index, value);
}
 
template<class T>
mi::Sint32 set_value(
    mi::neuraylib::IAttribute_set* attribute_set, const char* name, const char* key, const T& value)
{
    mi::base::Handle<mi::IData> data( attribute_set->edit_attribute<mi::IData>( name));
    if( !data)
        return -4;
    return set_value( data.get(), key, value);
}
 
template<class T>
mi::Sint32 set_value(
    mi::neuraylib::IAttribute_set* attribute_set, const char* name, const T* values, mi::Size n)
{
    mi::base::Handle<mi::IData> data( attribute_set->edit_attribute<mi::IData>( name));
    if( !data)
        return -4;
    return set_value( data.get(), values, n);
}
 
template<class T>
mi::Sint32 set_value(
    mi::neuraylib::IAttribute_set* attribute_set, const char* name, const std::vector<T>& values)
{
    mi::base::Handle<mi::IData> data( attribute_set->edit_attribute<mi::IData>( name));
    if( !data)
        return -4;
    return set_value( data.get(), values);
}
 
template<class T>
mi::Sint32 get_value(
    const mi::neuraylib::IAttribute_set* attribute_set, const char* name, T& value)
{
    mi::base::Handle<const mi::IData> data( attribute_set->access_attribute<mi::IData>( name));
    if( !data)
        return -4;
    return get_value( data.get(), value);
}
 
template<class T>
mi::Sint32 get_value(
    const mi::neuraylib::IAttribute_set* attribute_set, const char* name, mi::Size index, T& value)
{
    mi::base::Handle<const mi::IData> data( attribute_set->access_attribute<mi::IData>( name));
    if( !data)
        return -4;
    return get_value( data.get(), index, value);
}
 
template<class T>
mi::Sint32 get_value(
    const mi::neuraylib::IAttribute_set* attribute_set, const char* name, const char* key, T& value)
{
    mi::base::Handle<const mi::IData> data( attribute_set->access_attribute<mi::IData>( name));
    if( !data)
        return -4;
    return get_value( data.get(), key, value);
}
 
template<class T>
mi::Sint32 get_value(
    const mi::neuraylib::IAttribute_set* attribute_set, const char* name, T* values, mi::Size n)
{
    mi::base::Handle<const mi::IData> data( attribute_set->access_attribute<mi::IData>( name));
    if( !data)
        return -4;
    return get_value( data.get(), values, n);
}
 
template<class T>
mi::Sint32 get_value(
    const mi::neuraylib::IAttribute_set* attribute_set, const char* name, std::vector<T>& values)
{
    mi::base::Handle<const mi::IData> data( attribute_set->access_attribute<mi::IData>( name));
    if( !data)
        return -4;
    return get_value( data.get(), values);
}
 // end group mi_neuray_types
 
} // namespace mi
 
#endif // MI_NEURAYLIB_SET_GET_H