agent.h

// Copyright Maciej Sobczak 2008-2022.
// This file is part of YAMI4.
// See the package-level LICENSE.txt file.
 
#ifndef YAMICPP_AGENT_H_INCLUDED
#define YAMICPP_AGENT_H_INCLUDED
 
#include "agent_impl_base.h"
#include "connection_event_generic_dispatcher.h"
#include "event_callback.h"
#include "incoming_message_generic_dispatcher.h"
#include "io_error_generic_dispatcher.h"
#include "outgoing_message.h"
#include "outgoing_message_generic_dispatcher.h"
#include "parameters.h"
#include <yami4-core/dll.h>
#include <memory>
#include <string>
 
namespace yami
{
 
class value_publisher;
 
namespace details
{
class agent_impl;
} // namespace details
 
class DLL agent
{
public:
 
    typedef long long outgoing_message_id;
 
    agent(const parameters & options = parameters());
 
    agent(event_callback & event_listener,
        const parameters & options = parameters());
 
    ~agent();
 
    std::string add_listener(const std::string & listener);
 
    void remove_listener(const std::string & listener);
 
    template <typename functor>
    void register_object(const std::string & object_name, functor & f)
    {
        std::unique_ptr<details::incoming_message_dispatcher_base> object(
            new details::incoming_message_generic_dispatcher<functor>(f));
 
        pimpl_base_->register_object(object_name, object);
    }
 
    void register_raw_object(const std::string & object_name,
        void (* callback)(incoming_message & im, void * hint), void * hint);
 
    void register_value_publisher(const std::string & object_name,
        value_publisher & publisher);
 
    void unregister_object(const std::string & object_name);
 
    void open_connection(const std::string & target);
 
    void open_connection(const std::string & target,
        const parameters & options);
 
    outgoing_message_id get_next_message_id();
 
    std::unique_ptr<outgoing_message> send(
        const std::string & target,
        const std::string & object_name,
        const std::string & message_name,
        const serializable & content = parameters(),
        std::size_t priority = 0,
        bool auto_connect = true);
 
    void send(
        outgoing_message & message,
        const std::string & target,
        const std::string & object_name,
        const std::string & message_name,
        const serializable & content = parameters(),
        std::size_t priority = 0,
        bool auto_connect = true);
 
    template <typename functor>
    outgoing_message_id send(
        functor & f,
        const std::string & target,
        const std::string & object_name,
        const std::string & message_name,
        const serializable & content = parameters(),
        std::size_t priority = 0,
        bool auto_connect = true)
    {
        std::unique_ptr<details::outgoing_message_dispatcher_base>
            outgoing_message_callback(
            new details::outgoing_message_generic_dispatcher<functor>(f));
 
        return pimpl_base_->send(outgoing_message_callback,
            target, object_name, message_name,
            content, priority, auto_connect);
    }
    
    std::unique_ptr<outgoing_message> send(
        const std::string & target,
        const serializable & header,
        const serializable & content,
        outgoing_message_id message_id,
        std::size_t priority = 0,
        bool auto_connect = true);
 
    void send(
        outgoing_message & message,
        const std::string & target,
        const serializable & header,
        const serializable & content,
        outgoing_message_id message_id,
        std::size_t priority = 0,
        bool auto_connect = true);
 
    template <typename functor>
    void send(
        functor & f,
        const std::string & target,
        const serializable & header,
        const serializable & content,
        outgoing_message_id message_id,
        std::size_t priority = 0,
        bool auto_connect = true)
    {
        std::unique_ptr<details::outgoing_message_dispatcher_base>
            outgoing_message_callback(
            new details::outgoing_message_generic_dispatcher<functor>(f));
 
        pimpl_base_->send(outgoing_message_callback,
            target, header, content, message_id,
            priority, auto_connect);
    }
    
    void clean_outgoing_message_callback(outgoing_message_id id);
 
    void send_one_way(const std::string & target,
        const serializable & header,
        const serializable & content,
        outgoing_message_id message_id,
        std::size_t priority = 0,
        bool auto_connect = true);
 
    void send_one_way(const std::string & target,
        const std::string & object_name,
        const std::string & message_name,
        const serializable & content = parameters(),
        std::size_t priority = 0,
        bool auto_connect = true);
 
    void close_connection(const std::string & target,
        std::size_t priority = 0);
 
    void hard_close_connection(const std::string & target);
 
    template <typename functor>
    void register_connection_event_monitor(functor & f)
    {
        std::unique_ptr<details::connection_event_dispatcher_base> monitor(
            new details::connection_event_generic_dispatcher<functor>(f));
 
        pimpl_base_->register_connection_event_monitor(monitor);
    }
 
    template <typename functor>
    void register_io_error_logger(functor & f)
    {
        std::unique_ptr<details::io_error_dispatcher_base> logger(
            new details::io_error_generic_dispatcher<functor>(f));
 
        pimpl_base_->register_io_error_logger(logger);
    }
 
    void get_outgoing_flow_state(std::size_t & current_level,
        std::size_t & high_water_mark, std::size_t & low_water_mark) const;
 
    void get_channel_usage(std::size_t & max_allowed, std::size_t & used);
    
    std::size_t get_pending_outgoing_bytes(const std::string & target);
    
    void run_worker();
 
    void run_dispatcher(std::size_t dispatcher_index);
    
private:
    agent(const agent &);
    void operator=(const agent &);
 
    details::agent_impl * pimpl_;
    details::agent_impl_base * pimpl_base_;
};
 
} // namespace yami
 
#endif // YAMICPP_AGENT_H_INCLUDED