efl/src/lib/ecore_con/ecore_con_base.eo

abstract Ecore.Con.Base (Eo.Base) {
   legacy_prefix: ecore_con;
   eo_prefix: ecore_con_obj;
   data: null;
   properties {
      ip {
         /**
          * Control the IP address of a server that has been connected to.
          *
          * The param is a pointer to an internal string that contains the IP address of
          * the connected server in the form "XXX.YYY.ZZZ.AAA" IP notation.
          * This string should not be modified or trusted to stay valid after
          * deletion for the @p svr object. If no IP is known @c NULL is
          * returned.
          */
         get {
             legacy: null;
         }
         values {
            const(char)* ip; /*@ The IP address */
         }
      }
      uptime {
         /*@
          * @brief Check how long the object has been connected
          *
          * This function is used to find out how long a client has been connected for.
          */
         get {
             legacy: null;
         }
         values {
            double uptime; /*@ The total time, in seconds, that the object has been connected. */
         }
      }
      port {
         /*@
          * @brief Return the port that the obj is connected to
          *
          */
         set {
             legacy: null;
         }
         get {
             legacy: null;
         }
         values {
            int port; /*@ The The port that obj is connected to, or -1 on error. */
         }
      }
      fd {
         /*@
          * Get the fd that the server is connected to
          *
          * This function returns the fd which is used by the underlying server connection.
          * It should not be tampered with unless you REALLY know what you are doing.
          * @note This function is only valid for servers created with ecore_con_server_connect()
          * @warning Seriously. Don't use this unless you know what you are doing.
          * @since 1.1
          */
         get {
             legacy: null;
         }
         values {
            int fd; /*@ The fd, or -1 on failure. */
         }
      }
      connected {
         /*@
          * Returns whether the client is still connected
          */
         get {
             legacy: null;
         }
         values {
            bool connected; /*@ Returns True if connected, False otherwise. */
         }
      }
      timeout {
         /*@
          * Control the default time after which an inactive client will be disconnected
          *
          * This function is used by the server to set the default idle timeout on
          * clients. If the any of the clients becomes idle for a time higher than this
          * value, it will be disconnected. A value of < 1 disables the idle timeout.
          *
          * This timeout is not affected by the one set by
          * ecore_con_client_timeout_set(). A client will be disconnected whenever the
          * client or the server timeout is reached. That means, the lower timeout value
          * will be used for that client if ecore_con_client_timeout_set() is used on it.
          */
         set {
             legacy: null;
         }
         get {
             legacy: null;
         }
         values {
            double timeout; /*@ The timeout, in seconds, to disconnect after. */
         }
      }
   }
   methods {
      flush {
         /*@
          * Flushes all pending data to the given server.
          *
          * This function will block until all data is sent to the server.
          */
         legacy: null;
      }
      send {
         /**
          * Sends the given data to the given server.
          *
          * This function will send the given data to the server as soon as the program
          * is back to the main loop. Thus, this function returns immediately
          * (non-blocking). If the data needs to be sent @b now, call
          * ecore_con_server_flush() after this one.
          *
          * @see ecore_con_client_send()
          * @see ecore_con_server_flush()
          */
         legacy: null;

         params {
            const(void)* data; /*@ The given data */
            int size; /*@ Length of the data, in bytes. */
         }
         return: int; /*@ The number of bytes sent.  @c 0 will be returned if there is an error. */
      }
      lookup @class {
         /*@
          * Do an asynchronous DNS lookup.
          *
          * @param name IP address or server name to translate.
          * @param done_cb Callback to notify when done.
          * @param data User data to be given to done_cb.
          * @return @c EINA_TRUE if the request did not fail to be set up, @c EINA_FALSE
          * if it failed.
          *
          * This function performs a DNS lookup on the hostname specified by @p name,
          * then calls @p done_cb with the result and the @p data given as parameter.
          * The result will be given to the @p done_cb as follows:
          * @li @c canonname - the canonical name of the address
          * @li @c ip - the resolved ip address
          * @li @c addr - a pointer to the socket address
          * @li @c addrlen - the length of the socket address, in bytes
          * @li @c data - the data pointer given as parameter to ecore_con_lookup()
          */
         params {
            const(char)* name @nonull; /*@ Hostname to lookup. */
            Ecore_Con_Dns_Cb done_cb; /*@ The callback to be called wehn lookup is done. */
            const(void)* data; /*@ User data for the callback. */
         }
         return: bool;
      }
   }
   implements {
      @virtual .ip.get;
      @virtual .uptime.get;
      @virtual .port.set;
      @virtual .port.get;
      @virtual .fd.get;
      @virtual .connected.get;
      @virtual .timeout.set;
      @virtual .timeout.get;
      @virtual .flush;
      @virtual .send;
   }
   events {
        data,received: Ecore_Con_Event_Data_Received;
        connection,upgraded;
        connection,error: const(char) *;
   }
}

/* FIXME: Should actually be a binbuf. */
type Ecore_Con_Event_Data_Received: struct {
    data: void *; /*@ The data thet got sent. */
    size: int; /*@ The length of the data sent. */
};

type Ecore_Con_Dns_Cb: func void (const(char) *,
                                 const(char) *,
                                 struct sockaddr *,
                                 int,
                                 void *);

/* FIXME: Ecore_Con_Dns_Cb should be like this:
type Ecore_Con_Dns_Cb: func void (const(char) *canonname,
                                 const(char) *ip,
                                 struct sockaddr *addr,
                                 int addrlen,
                                 void *data);


* Add events (to all of the ecore con stuff, e.g url).
* Make server the father of the client - make sure I don't leak references.
*
* Still need to add constructor client, and most likely migrate ecore_con_eet.
*
* Split server to two classes, listener and connector (or w/e).
*
* Mark the constructing properties all around.
*/