tianzuo.ZhuiriInterface.h

Go to the documentation of this file.

 
// *@file tianzuo_ZhuiriInterface.h
// *@brief 天佐.追日靴 (tianzuo.Zhuiri)
// *@version 1.0
// *@section LICENSE Copyright © 2003-2103 郑天佐 Corporation
// *@author 郑天佐 (zhengtianzuo)
// *@date 2013-4-3
#pragma once
#include "tianzuo.Zhuiri.h"
 
#undef tianzuo_Zhuiri_lib
#if defined (WIN32)
#define tianzuo_Zhuiri_atr
#if defined (tianzuo_Zhuiri_dllexport)
#define tianzuo_Zhuiri_lib _declspec(dllexport)
#else
#define tianzuo_Zhuiri_lib _declspec(dllimport)
#endif
#else
#define tianzuo_Zhuiri_atr __attribute__((visibility("default")))
#define tianzuo_Zhuiri_lib
#endif
 
typedef struct Zhuiri_param_tag {
    Zhuiri_param_tag() {
        m_sender_index = 0;
        m_init_server_port = 0;
        m_msg_init_size = 0;
        m_recv_ex_data_max = 0;
        m_retry_max = 0;
        m_retry_all_number = 0;
        m_init_retry_time = 0;
    }
 
    Zhuiri_param_tag(
        int sender_index,
        int init_server_port,
        int msg_init_size,
        int recv_ex_data_max,
        int retry_max,
        int retry_all_number,
        int init_retry_time) {
        m_sender_index = sender_index;
        m_init_server_port = init_server_port;
        m_msg_init_size = msg_init_size;
        m_recv_ex_data_max = recv_ex_data_max;
        m_retry_max = retry_max;
        m_retry_all_number = retry_all_number;
        m_init_retry_time = init_retry_time;
    }
 
    int get_sender_index() const {
        return m_sender_index;
    }
 
    void set_sender_index(int sender_index) {
        m_sender_index = sender_index;
    }
 
    int get_init_server_port() const {
        return m_init_server_port;
    }
 
    void set_init_server_port(int init_server_port) {
        m_init_server_port = init_server_port;
    }
 
    int get_msg_init_size() const {
        return m_msg_init_size;
    }
 
    void set_msg_init_size(int msg_init_size) {
        m_msg_init_size = msg_init_size;
    }
 
    int get_recv_ex_data_max() const {
        return m_recv_ex_data_max;
    }
 
    void set_recv_ex_data_max(int recv_ex_data_max) {
        m_recv_ex_data_max = recv_ex_data_max;
    }
 
    int get_retry_max() const {
        return m_retry_max;
    }
 
    void set_retry_max(int retry_max) {
        m_retry_max = retry_max;
    }
 
    int get_retry_all_number() const {
        return m_retry_all_number;
    }
 
    void set_retry_all_number(int retry_all_number) {
        m_retry_all_number = retry_all_number;
    }
 
    int get_init_retry_time() const {
        return m_init_retry_time;
    }
 
    void set_init_retry_time(int init_retry_time) {
        m_init_retry_time = init_retry_time;
    }
 
private:
    int m_sender_index;
    int m_init_server_port;                                          
    int m_msg_init_size;                                             
    int m_recv_ex_data_max;                                          
    int m_retry_max;                                                 
    int m_retry_all_number;                                          
    int m_init_retry_time;                                           
} Zhuiri_param_struct, *Zhuiri_param_pointer;
 
typedef struct Zhuiri_send_param_tag {
    Zhuiri_send_param_tag() {
        m_sender_index = 0;
        m_ip = 0;
        m_port = 0;
        m_sign = 0;
        m_function = 0;
        m_send_data = NULL;
        m_send_size = 0;
    }
 
    Zhuiri_send_param_tag(int sender_index, int ip, int port, int sign,
                         int function, char *send_data, int send_size) {
        m_sender_index = sender_index;
        m_ip = ip;
        m_port = port;
        m_sign = sign;
        m_function = function;
        m_send_data = send_data;
        m_send_size = send_size;
    }
 
    int get_sender_index() const {
        return m_sender_index;
    }
 
    void set_sender_index(int sender_index) {
        m_sender_index = sender_index;
    }
 
    int get_ip() const {
        return m_ip;
    }
 
    void set_ip(int ip) {
        m_ip = ip;
    }
 
    int get_port() const {
        return m_port;
    }
 
    void set_port(int port) {
        m_port = port;
    }
 
    int get_sign() const {
        return m_sign;
    }
 
    void set_sign(int sign) {
        m_sign = sign;
    }
 
    int get_function() const {
        return m_function;
    }
 
    void set_function(int function) {
        m_function = function;
    }
 
    char *get_send_data() const {
        return m_send_data;
    }
 
    void set_send_data(char * send_data) {
        m_send_data = send_data;
    }
 
    int get_send_size() const {
        return m_send_size;
    }
 
    void set_send_size(int send_size) {
        m_send_size = send_size;
    }
 
private:
    int m_sender_index;                                             
    int m_ip;                                                       
    int m_port;                                                     
    int m_sign;                                                     
    int m_function;                                                 
    char *m_send_data;                                              
    int m_send_size;                                                
} Zhuiri_send_param_struct, *Zhuiri_send_param_pointer;
 
class tianzuo_Zhuiri_lib tianzuo_ZhuiriInt {
 public:
    tianzuo_ZhuiriInt() {}
    virtual ~tianzuo_ZhuiriInt() {}
 
    virtual int initialize(
        const char *ip_addr, int port,
        const void *callback, const void *context, int const heart_check_time,
        bool log_trace
#ifdef WIN32
        , void * iocp = nullptr
#endif
    ) = 0;
 
    virtual int terminate() = 0;
 
    virtual int set_param(Zhuiri_param_pointer param) = 0;
 
    virtual int add_sender(
        int *sender_index, int const sign) = 0;
 
    virtual int begin_recv() = 0;
 
    virtual int stop_recv() = 0;
 
    virtual int data_free(
        void *Zhuiri, int const data_index) const = 0;
 
    virtual int send(Zhuiri_send_param_pointer send_param) = 0;
 
    virtual int get_status() const = 0;
 
    virtual int get_type() = 0;
 
    virtual int get_bind_port() = 0;
 
    virtual int heart_add(Zhuiri_pkg_recv_heart_pointer recv_heart) = 0;
 
    virtual int heart_modify(
        int const data_id, int const ip, int const port) = 0;
 
    virtual int heart_update(int const data_id) = 0;
 
    virtual int heart_remove(int const data_id) = 0;
};
 
class tianzuo_Zhuiri_lib tianzuo_ZhuiriInterface {
 public:
    tianzuo_ZhuiriInterface();
 
    virtual ~tianzuo_ZhuiriInterface();
 
    static tianzuo_ZhuiriInt *initialize();
 
    static void terminate(tianzuo_ZhuiriInt **Zhuiri);
};
 
class tianzuo_Zhuiri_lib tianzuo_DataQueue {
 public:
    tianzuo_DataQueue() {}
    virtual ~tianzuo_DataQueue() {}
 
    virtual int initialize(int const init_size) = 0;
 
    virtual void terminate() = 0;
 
    virtual int push_back(const Zhuiri_data_pkg_pointer data) = 0;
 
    virtual int pop_up(const Zhuiri_data_pkg_pointer data) = 0;
 
    virtual void alloc_send_data(
        Zhuiri_data_pkg_pointer *data, int const space_size) = 0;
 
    virtual void free_send_data() = 0;
 
    virtual int get_used_count() const = 0;
 
    virtual int get_unuse_count() const = 0;
 
    virtual int get_all_count() const = 0;
 
    virtual void clear() = 0;
};
 
class tianzuo_Zhuiri_lib tianzuo_DataQueueInterface {
 public:
    tianzuo_DataQueueInterface();
 
    virtual ~tianzuo_DataQueueInterface();
 
    static tianzuo_DataQueue *initialize();
 
    static void terminate(tianzuo_DataQueue **data_queue);
};
 
#ifdef __cplusplus
extern "C"
{
#endif
 
    tianzuo_Zhuiri_lib tianzuo_ZhuiriInt* tianzuo_ZhuiriInterface_initialize();
 
    tianzuo_Zhuiri_lib void tianzuo_ZhuiriInterface_terminate(tianzuo_ZhuiriInt** ZhuiriInt_pointer);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_initialize(
        tianzuo_ZhuiriInt* ZhuiriInt_pointer, const char* ip_addr, int port,
        const void* callback, const void* context, int const heart_check_time, bool log_trace
#ifdef WIN32
        , void* iocp = nullptr
#endif
    );
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_terminate(tianzuo_ZhuiriInt* ZhuiriInt_pointer);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_set_param(tianzuo_ZhuiriInt* ZhuiriInt_pointer,
        int sender_index, int init_server_port, int msg_init_size,
        int recv_ex_data_max, int retry_max, int retry_all_number,
        int init_retry_time);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_add_sender(tianzuo_ZhuiriInt* ZhuiriInt_pointer,
        int *sender_index, int const sign);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_begin_recv(tianzuo_ZhuiriInt* ZhuiriInt_pointer);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_stop_recv(tianzuo_ZhuiriInt* ZhuiriInt_pointer);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_data_free(tianzuo_ZhuiriInt* ZhuiriInt_pointer, void *Zhuiri, int const data_index);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_send(tianzuo_ZhuiriInt* ZhuiriInt_pointer, 
        int sender_index, int ip, int port, int sign, int function, char* send_data, int send_size);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_get_status(tianzuo_ZhuiriInt* ZhuiriInt_pointer);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_get_type(tianzuo_ZhuiriInt* ZhuiriInt_pointer);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_get_bind_port(tianzuo_ZhuiriInt* ZhuiriInt_pointer);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_heart_add(tianzuo_ZhuiriInt* ZhuiriInt_pointer, int user_id, int ip_adrs, int port, int user_type, int send_time, int sender_user_id, int sender_user_type);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_heart_modify(tianzuo_ZhuiriInt* ZhuiriInt_pointer,
        int const data_id, int const ip, int const port);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_heart_update(tianzuo_ZhuiriInt* ZhuiriInt_pointer, int const data_id);
 
    tianzuo_Zhuiri_lib int tianzuo_ZhuiriInt_heart_remove(tianzuo_ZhuiriInt* ZhuiriInt_pointer, int const data_id);
 
    tianzuo_Zhuiri_lib tianzuo_DataQueue* tianzuo_DataQueueInterface_initialize();
 
    tianzuo_Zhuiri_lib void tianzuo_DataQueueInterface_terminate(tianzuo_DataQueue** DataQueue_pointer);
 
    tianzuo_Zhuiri_lib int tianzuo_DataQueueInt_initialize(int init_size);
 
#ifdef __cplusplus
}
#endif