itransaction.h

Go to the documentation of this file.

/***************************************************************************************************
 * Copyright 2025 NVIDIA Corporation. All rights reserved.
 **************************************************************************************************/
 
#ifndef MI_NEURAYLIB_ITRANSACTION_H
#define MI_NEURAYLIB_ITRANSACTION_H
 
#include <mi/base/interface_declare.h>
#include <mi/neuraylib/type_traits.h>
#include <mi/neuraylib/version.h>
 
namespace mi {
 
class IArray;
 
namespace neuraylib {
 
class IScope;
 
class ITransaction : public
    mi::base::Interface_declare<0x6ca1f0c2,0xb262,0x4f09,0xa6,0xa5,0x05,0xae,0x14,0x45,0xed,0xfa>
{
public:
    static const mi::Uint8 LOCAL_SCOPE = 255;
 
 
 
    virtual const char* get_id() const = 0;
 
    virtual IScope* get_scope() const = 0;
 
 
 
    virtual bool is_open() const = 0;
 
    virtual Sint32 commit() = 0;
 
    virtual void abort() = 0;
 
 
 
    virtual base::IInterface* create(
        const char* type_name,
        Uint32 argc = 0,
        const base::IInterface* argv[] = nullptr) = 0;
 
    template<class T>
    T* create(
        const char* type_name,
        Uint32 argc = 0,
        const base::IInterface* argv[] = nullptr)
    {
        base::IInterface* ptr_iinterface = create( type_name, argc, argv);
        if( !ptr_iinterface)
            return 0;
        T* ptr_T = static_cast<T*>( ptr_iinterface->get_interface( typename T::IID()));
        ptr_iinterface->release();
        return ptr_T;
    }
 
    template<class T>
    T* create()
    {
        return create<T>( Type_traits<T>::get_type_name());
    }
 
 
 
 
    virtual Sint32 store(
        base::IInterface* db_element, const char* name, Uint8 privacy = LOCAL_SCOPE) = 0;
 
 
 
    virtual const base::IInterface* access( const char* name) = 0;
 
    template<class T>
    const T* access( const char* name)
    {
        const base::IInterface* ptr_iinterface = access( name);
        if( !ptr_iinterface)
            return nullptr;
        const T* ptr_T = static_cast<const T*>( ptr_iinterface->get_interface( typename T::IID()));
        ptr_iinterface->release();
        return ptr_T;
    }
 
    virtual base::IInterface* edit( const char* name) = 0;
 
    template<class T>
    T* edit( const char* name)
    {
        base::IInterface* ptr_iinterface = edit( name);
        if( !ptr_iinterface)
            return nullptr;
        T* ptr_T = static_cast<T*>( ptr_iinterface->get_interface( typename T::IID()));
        ptr_iinterface->release();
        return ptr_T;
    }
 
 
 
#ifdef MI_NEURAYLIB_DEPRECATED_ITRANSACTION_COPY_DEFAULT_PRIVACY_LEVEL_ZERO
    virtual Sint32 copy( const char* source, const char* target, Uint8 privacy = 0) = 0;
#else
    virtual Sint32 copy( const char* source, const char* target, Uint8 privacy = LOCAL_SCOPE) = 0;
#endif
 
    virtual Sint32 remove( const char* name, bool only_localized = false) = 0;
 
    virtual const char* name_of( const base::IInterface* db_element) const = 0;
 
    virtual Sint32 get_privacy_level( const char* name) const = 0;
 
 
 
    virtual const char* get_time_stamp() const = 0;
 
    virtual const char* get_time_stamp( const char* element) const = 0;
 
    virtual bool has_changed_since_time_stamp(
        const char* element, const char* time_stamp) const = 0;
 
 
 
    virtual IArray* list_elements(
        const char* root_element,
        const char* name_pattern = nullptr,
        const IArray* type_names = nullptr) const = 0;
 
};
 // end group mi_neuray_database_access
 
} // namespace neuraylib
 
} // namespace mi
 
#endif // MI_NEURAYLIB_ITRANSACTION_H