ibridge_client.h

Go to the documentation of this file.

/***************************************************************************************************
 * Copyright 2023 NVIDIA Corporation. All rights reserved.
 **************************************************************************************************/
 
#ifndef MI_NEURAYLIB_IBRIDGE_CLIENT_H
#define MI_NEURAYLIB_IBRIDGE_CLIENT_H
 
#include <mi/base/enums.h>
#include <mi/base/interface_implement.h>
#include <mi/neuraylib/iserializer.h>
 
namespace mi {
 
class IMap;
class IString;
 
namespace base { class ILogger; }
 
namespace neuraylib {
class IDeserializer;
class ITransaction;
class ITag_set;
}
 
namespace bridge {
 
class IClient_video_context;
 
enum Client_job_state
{
    CLIENT_JOB_DETECTING_CHANGES = 0,
 
    CLIENT_JOB_PREPARING = 1,
 
    CLIENT_JOB_QUERYING_CACHE_STATUS = 2,
 
    CLIENT_JOB_UPLOADING = 3,
 
    CLIENT_JOB_PENDING = 4,
 
    CLIENT_JOB_DONE = 5,
 
    CLIENT_JOB_FORCE_32_BIT = 0xffffffffU
};
 
mi_static_assert( sizeof( Client_job_state) == sizeof( Uint32));
 
class IClient_job_progress : public
    mi::base::Interface_declare<0x7f51a745,0xfcf0,0x4b2d,0x92,0x93,0x2b,0x84,0xd7,0x8c,0xc0,0xe6>
{
public:
    virtual Client_job_state get_state() const = 0;
 
    virtual Size get_updated_element_count() const = 0;
 
    virtual Size get_pending_hash_calculation_count() const = 0;
 
    virtual Size get_pending_cache_status_count() const = 0;
 
    virtual Size get_cache_miss_count() const = 0;
 
    virtual Size get_cache_miss_bytes() const = 0;
 
    virtual Size get_uploaded_cache_miss_count() const = 0;
 
    virtual Size get_uploaded_cache_miss_bytes() const = 0;
 
    virtual Size get_pending_data_serialization_count() const = 0;
 
    virtual const char* get_currently_uploaded_element_name() const = 0;
 
    virtual Size get_currently_uploaded_element_size() const = 0;
 
    virtual Size get_currently_uploaded_element_uploaded_bytes() const = 0;
};
 
class IElement_set : public
    mi::base::Interface_declare<0x2242471d,0x96f3,0x4962,0x84,0x7e,0xd1,0x20,0xa9,0x6b,0xb6,0x98>
{
public:
    virtual Size get_length() const = 0;
 
    virtual const char* get_element( Size index) const = 0;
 
    virtual void add_element( const char* element_name) = 0;
};
 
class IClient_job : public
    mi::base::Interface_declare<0xe02e4aeb,0x6edd,0x4e40,0xbb,0xe0,0x6c,0xc5,0xe7,0x69,0xa6,0xe,
    neuraylib::ISerializable>
{
public:
    virtual void get_references( neuraylib::ITag_set* result) const = 0;
 
    virtual void get_references( IElement_set* result) const = 0;
 
    virtual bool upload_only() const = 0;
 
    virtual void receive_remote_result(
        neuraylib::IDeserializer* deserializer, bool last_result) = 0;
 
    virtual void progress_callback( IClient_job_progress* job_progress) = 0;
 
    virtual void error_callback( Sint32 error_code, const char* msg) = 0;
};
 
template <Uint32 i_id1, Uint16 i_id2, Uint16 i_id3
, Uint8 i_id4, Uint8 i_id5, Uint8 i_id6, Uint8 i_id7
, Uint8 i_id8, Uint8 i_id9, Uint8 i_id10, Uint8 i_id11
, class I = IClient_job>
class Client_job : public base::Interface_implement<I>
{
public:
    typedef Client_job<i_id1,i_id2,i_id3,i_id4,i_id5,i_id6,i_id7,i_id8,i_id9,i_id10,i_id11,I> Self;
 
    typedef base::Uuid_t<i_id1,i_id2,i_id3,i_id4,i_id5,i_id6,i_id7,i_id8,i_id9,i_id10,i_id11> IID;
 
    static bool compare_iid( const base::Uuid& iid)
    {
        if( iid == IID())
            return true;
        return I::compare_iid( iid);
    }
 
    virtual const base::IInterface* get_interface( const base::Uuid& interface_id) const
    {
        if( interface_id == IID()) {
            const Self* self = static_cast<const Self*>( this);
            self->retain();
            return self;
        }
        return I::get_interface_static( this, interface_id);
    }
 
    virtual base::IInterface* get_interface( const base::Uuid& interface_id)
    {
        if( interface_id == IID()) {
            Self* self = static_cast<Self*>( this);
            self->retain();
            return self;
        }
        return I::get_interface_static( this, interface_id);
    }
 
    using base::Interface_implement<I>::get_interface;
 
    virtual base::Uuid get_class_id() const
    {
        return IID();
    }
 
    virtual void deserialize( neuraylib::IDeserializer* deserializer)
    {
        // avoid warnings
        (void) deserializer;
    }
 
    virtual void get_references( neuraylib::ITag_set* result) const
    {
        // avoid warnings
        (void) result;
    }
 
    virtual void get_references( IElement_set* result) const
    {
        // avoid warnings
        (void) result;
    }
 
    virtual bool upload_only() const { return false; }
};
 
class Update_job : public mi::bridge::Client_job<
    0xf9b3c8e2,0x7688,0x4bf8,0x91,0x36,0xcd,0x3a,0x3f,0x51,0x30,0x7a>
{
    void serialize( neuraylib::ISerializer* serializer) const
    {
        // avoid warnings
        (void) serializer;
    }
 
    void receive_remote_result( neuraylib::IDeserializer* deserializer, bool last_result)
    {
        // avoid warnings
        (void) deserializer;
        (void) last_result;
    }
};
 
 
enum Client_session_state
{
    CLIENT_SESSION_CONNECTING,
 
    CLIENT_SESSION_CONNECTED,
 
    CLIENT_SESSION_PENDING,
 
    CLIENT_SESSION_CLOSED
};
 
mi_static_assert( sizeof( Client_session_state) == sizeof( Uint32));
 
class IClient_session_state_callback : public
    mi::base::Interface_declare<0x9ea6d3b3,0x3d0b,0x4d10,0x89,0xc8,0x89,0xf1,0x20,0x49,0xc6,0xe1>
{
public:
    virtual void session_state_callback( Client_session_state state) = 0;
};
 
class IClient_measure_bandwidth_callback : public
    mi::base::Interface_declare<0x80cf9612,0x3fd4,0x4ed0,0xb1,0x63,0xc0,0xd9,0x84,0xe2,0x6,0xaa>
{
public:
    virtual void progress_callback( Size bytes_done, Size total_bytes) = 0;
 
    virtual void done_callback( Size total_bytes, Float64 total_time) = 0;
 
    virtual void error_callback( Sint32 error_code) = 0;
};
 
class IClient_session : public
    mi::base::Interface_declare<0x70bb8712,0x1305,0x4c76,0xb9,0x38,0xad,0x27,0x91,0xea,0xbd,0x78>
{
public:
    virtual Client_session_state get_state() = 0;
 
    virtual void add_session_state_callback( IClient_session_state_callback* callback) = 0;
 
    virtual void remove_session_state_callback( IClient_session_state_callback* callback) = 0;
 
    virtual Sint32 execute(IClient_job* job, neuraylib::ITransaction* transaction) = 0;
 
    virtual Sint32 cancel(IClient_job* job) = 0;
 
    virtual IClient_video_context* create_video_context() = 0;
 
    virtual Sint32 measure_bandwidth(
        IClient_measure_bandwidth_callback* progress_callback,
        bool upload,
        Uint32 package_size,
        Uint32 package_count = 1) = 0;
 
    virtual void set_receiving_logger( base::ILogger* logger) = 0;
 
    virtual base::ILogger* get_receiving_logger() const = 0;
 
    virtual Sint32 set_forwarding_log_level( base::Message_severity level) = 0;
 
    virtual base::Message_severity get_forwarding_log_level() const = 0;
 
    virtual Size get_bytes_written() const = 0;
 
    virtual Size get_bytes_read() const = 0;
 
    virtual Sint32 set_hash_overrides(
        const IMap* overrides, 
        const char* top_level_element,
        neuraylib::ITransaction* transaction) = 0;
    
};
 
class IBridge_client : public
    mi::base::Interface_declare<0xbe270827,0xad68,0x4044,0x94,0x6e,0x9d,0x41,0x4d,0xf,0x75,0x65>
{
public:
    virtual IClient_session* get_session(
        const char* application_url, const char* security_token = 0) = 0;
 
    virtual const char* get_bridge_protocol_version() const = 0;
};
 // end group mi_neuray_bridge_client
 
} // namespace bridge
 
} // namespace mi
 
#endif // MI_NEURAYLIB_IBRIDGE_CLIENT_H