agent.h

// Copyright Maciej Sobczak 2008-2022.
// This file is part of YAMI4.
// See the package-level LICENSE.txt file.
 
#ifndef YAMICORE_AGENT_H_INCLUDED
#define YAMICORE_AGENT_H_INCLUDED
 
#include "allocator.h"
#include "channel_descriptor.h"
#include "core.h"
#include "dll.h"
 
namespace yami
{
 
namespace details
{
class channel_group;
} // namespace details
 
namespace core
{
 
class parameters;
class serializable;
 
class DLL agent
{
public:
 
    agent();
 
    result init(
        incoming_message_dispatch_function dispatch_callback,
        void * dispatch_hint,
        closed_connection_function disconnection_hook = NULL,
        void * disconnection_hook_hint = NULL,
        allocator * alloc = NULL);
 
    result init(const parameters & configuration_options,
        incoming_message_dispatch_function dispatch_callback,
        void * dispatch_hint,
        closed_connection_function disconnection_hook = NULL,
        void * disconnection_hook_hint = NULL,
        allocator * alloc = NULL);
 
    void install_event_notifications(
        event_notification_function event_notification_callback,
        void * event_notification_hint);
 
    void install_frame_acceptor(
        frame_acceptor_function frame_acceptor,
        void * frame_acceptor_hint);
 
    void install_io_error_logger(
        io_error_function io_error_callback,
        void * io_error_callback_hint);
 
    void clean();
 
    ~agent();
 
    result open(const char * target);
 
    result open(const char * target, channel_descriptor & cd,
        bool & created_new_channel);
 
    result open(const char * target, channel_descriptor & cd,
        bool & created_new_channel, const parameters * overriding_options);
 
    result is_open(const char * target,
        channel_descriptor & existing_channel) const;
 
    result close(channel_descriptor cd, std::size_t priority = 0);
 
    result close(const char * target, std::size_t priority = 0);
 
    result hard_close(channel_descriptor cd);
 
    result hard_close(const char * target);
 
    result post(channel_descriptor cd,
        const serializable & message_header,
        const serializable & message_body,
        std::size_t priority = 0,
        message_progress_function progress_callback = NULL,
        void * progress_hint = NULL);
 
    result post(const char * target,
        const serializable & message_header,
        const serializable & message_body,
        std::size_t priority = 0,
        message_progress_function progress_callback = NULL,
        void * progress_hint = NULL);
 
    result add_listener(const char * target,
        new_incoming_connection_function connection_hook = NULL,
        void * connection_hook_hint = NULL,
        const char * * resolved_target = NULL);
 
    result remove_listener(const char * target);
 
    result do_some_work(std::size_t timeout,
        bool allow_outgoing_traffic = true,
        bool allow_incoming_traffic = true);
 
    result interrupt_work_waiter();
 
    void get_channel_usage(std::size_t & max_allowed, std::size_t & used);
    
    result get_pending_outgoing_bytes(
        channel_descriptor cd, std::size_t & bytes);
    result get_pending_outgoing_bytes(
        const char * target, std::size_t & bytes);
    
private:
 
    agent(const agent &);
    void operator=(const agent &);
 
    result do_init(const parameters * configuration_options,
        core::incoming_message_dispatch_function dispatch_callback,
        void * dispatch_hint,
        core::closed_connection_function disconnection_hook,
        void * disconnection_hook_hint,
        allocator * alloc);
 
    bool initialized_;
 
    standard_allocator default_alloc_;
    allocator * alloc_;
 
    details::channel_group * ch_group_;
    
    std::size_t max_channels_allowed_;
    std::size_t channels_used_;
};
 
} // namespace core
 
} // namespace yami
 
#endif // YAMICORE_AGENT_H_INCLUDED