agent.h

// Copyright Maciej Sobczak 2008-2020.
// This file is part of YAMI4.
//
// YAMI4 is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// YAMI4 is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with YAMI4.  If not, see <http://www.gnu.org/licenses/>.

#ifndef YAMICORE_AGENT_H_INCLUDED
#define YAMICORE_AGENT_H_INCLUDED

#include "allocator.h"
#include "channel_descriptor.h"
#include "core.h"
#include "dll.h"

#ifdef YAMI4_WITH_NETX
#include <nx_api.h>
#endif // YAMI4_WITH_NETX

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,
        void * working_area = NULL, std::size_t area_size = 0);

    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,
        void * working_area = NULL, std::size_t area_size = 0);

#ifdef YAMI4_WITH_NETX
    void set_netx_context(NX_IP * ip, NX_PACKET_POOL * packet_pool);
#endif // YAMI4_WITH_NETX
    
    void install_event_notifications(
        event_notification_function event_notification_callback,
        void * event_notification_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,
        void * working_area, std::size_t area_size);

    bool initialized_;

    details::allocator alloc_;
    bool uses_private_area_;

    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