EvdTransport

EvdTransport

Synopsis

struct              EvdTransportInterface;
gboolean            evd_transport_accept_peer           (EvdTransport *self,
                                                         EvdPeer *peer);
void                evd_transport_close_peer            (EvdTransport *self,
                                                         EvdPeer *peer,
                                                         gboolean gracefully,
                                                         GError **error);
EvdPeer *           evd_transport_create_new_peer       (EvdTransport *self);
EvdPeerManager *    evd_transport_get_peer_manager      (EvdTransport *self);
EvdPeer *           evd_transport_lookup_peer           (EvdTransport *self,
                                                         const gchar *peer_id);
void                evd_transport_open                  (EvdTransport *self,
                                                         const gchar *address,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);
gboolean            evd_transport_open_finish           (EvdTransport *self,
                                                         GAsyncResult *result,
                                                         GError **error);
gboolean            evd_transport_peer_is_connected     (EvdTransport *self,
                                                         EvdPeer *peer);
const gchar *       evd_transport_receive               (EvdTransport *self,
                                                         EvdPeer *peer,
                                                         gsize *size);
const gchar *       evd_transport_receive_text          (EvdTransport *self,
                                                         EvdPeer *peer);
gboolean            evd_transport_reject_peer           (EvdTransport *self,
                                                         EvdPeer *peer);
gboolean            evd_transport_send                  (EvdTransport *self,
                                                         EvdPeer *peer,
                                                         const gchar *buffer,
                                                         gsize size,
                                                         GError **error);
gboolean            evd_transport_send_text             (EvdTransport *self,
                                                         EvdPeer *peer,
                                                         const gchar *text,
                                                         GError **error);
void                evd_transport_set_peer_manager      (EvdTransport *self,
                                                         EvdPeerManager *peer_manager);

Description

Details

struct EvdTransportInterface

struct EvdTransportInterface {
  GTypeInterface parent_iface;

  /* virtual methods */
  gboolean  (* send)                 (EvdTransport    *self,
                                      EvdPeer         *peer,
                                      const gchar     *buffer,
                                      gsize            size,
                                      EvdMessageType   type,
                                      GError         **error);
  void      (* notify_receive)       (EvdTransport *self,
                                      EvdPeer      *peer);
  void      (* receive)              (EvdTransport *self,
                                      EvdPeer      *peer,
                                      const gchar  *buffer,
                                      gsize         size);

  void      (* notify_new_peer)      (EvdTransport *self, EvdPeer *peer);
  EvdPeer * (* create_new_peer)      (EvdTransport *self);

  void      (* notify_peer_closed)   (EvdTransport *self,
                                      EvdPeer      *peer,
                                      gboolean      gracefully);
  void      (* peer_closed)          (EvdTransport *self,
                                      EvdPeer      *peer,
                                      gboolean      gracefully);

  guint     (* notify_validate_peer) (EvdTransport *self, EvdPeer *peer);

  gboolean  (* peer_is_connected)    (EvdTransport *self, EvdPeer *peer);

  gboolean  (* accept_peer)          (EvdTransport *self, EvdPeer *peer);
  gboolean  (* reject_peer)          (EvdTransport *self, EvdPeer *peer);

  void      (* open)                 (EvdTransport       *self,
                                      const gchar        *address,
                                      GSimpleAsyncResult *async_result,
                                      GCancellable       *cancellable);

  /* signals */
  void (* signal_receive)        (EvdTransport *self,
                                  EvdPeer      *peer,
                                  gpointer      user_data);

  void  (* signal_new_peer)      (EvdTransport *self,
                                  EvdPeer      *peer,
                                  gpointer      user_data);
  void  (* signal_peer_closed)   (EvdTransport *self,
                                  EvdPeer      *peer,
                                  gboolean      gracefully,
                                  gpointer      user_data);

  guint (* signal_validate_peer) (EvdTransport *self,
                                  EvdPeer      *peer,
                                  gpointer      user_data);

  /* members */
  EvdPeerManager *peer_manager;

  /* padding for future expansion */
  void (* _padding_0_) (void);
  void (* _padding_1_) (void);
  void (* _padding_2_) (void);
  void (* _padding_3_) (void);
  void (* _padding_4_) (void);
  void (* _padding_5_) (void);
  void (* _padding_6_) (void);
  void (* _padding_7_) (void);
};


evd_transport_accept_peer ()

gboolean            evd_transport_accept_peer           (EvdTransport *self,
                                                         EvdPeer *peer);


evd_transport_close_peer ()

void                evd_transport_close_peer            (EvdTransport *self,
                                                         EvdPeer *peer,
                                                         gboolean gracefully,
                                                         GError **error);


evd_transport_create_new_peer ()

EvdPeer *           evd_transport_create_new_peer       (EvdTransport *self);

Returns :

. [transfer full]

evd_transport_get_peer_manager ()

EvdPeerManager *    evd_transport_get_peer_manager      (EvdTransport *self);

Returns :

. [transfer none]

evd_transport_lookup_peer ()

EvdPeer *           evd_transport_lookup_peer           (EvdTransport *self,
                                                         const gchar *peer_id);

Returns :

. [transfer none]

evd_transport_open ()

void                evd_transport_open                  (EvdTransport *self,
                                                         const gchar *address,
                                                         GCancellable *cancellable,
                                                         GAsyncReadyCallback callback,
                                                         gpointer user_data);

cancellable :

. [allow-none]

callback :

. [scope async][allow-none]

user_data :

. [allow-none]

evd_transport_open_finish ()

gboolean            evd_transport_open_finish           (EvdTransport *self,
                                                         GAsyncResult *result,
                                                         GError **error);


evd_transport_peer_is_connected ()

gboolean            evd_transport_peer_is_connected     (EvdTransport *self,
                                                         EvdPeer *peer);


evd_transport_receive ()

const gchar *       evd_transport_receive               (EvdTransport *self,
                                                         EvdPeer *peer,
                                                         gsize *size);

size :

. [out]

Returns :

. [transfer none]

evd_transport_receive_text ()

const gchar *       evd_transport_receive_text          (EvdTransport *self,
                                                         EvdPeer *peer);

Returns :

. [transfer none]

evd_transport_reject_peer ()

gboolean            evd_transport_reject_peer           (EvdTransport *self,
                                                         EvdPeer *peer);


evd_transport_send ()

gboolean            evd_transport_send                  (EvdTransport *self,
                                                         EvdPeer *peer,
                                                         const gchar *buffer,
                                                         gsize size,
                                                         GError **error);


evd_transport_send_text ()

gboolean            evd_transport_send_text             (EvdTransport *self,
                                                         EvdPeer *peer,
                                                         const gchar *text,
                                                         GError **error);


evd_transport_set_peer_manager ()

void                evd_transport_set_peer_manager      (EvdTransport *self,
                                                         EvdPeerManager *peer_manager);