Fix definition of mesh::set_channel_accept_cb() and _poll_cb().

[meshlink] / src / meshlink++.h

diff --git a/src/meshlink++.h b/src/meshlink++.h
index 8f852d9f1d22213e9f29c988a82e6c1a25542b97..7624863b8a881aaa2d0b42dc4820f95c6cf91684 100644 (file)
--- a/src/meshlink++.h
+++ b/src/meshlink++.h
@@ -77,6 +77,13 @@ namespace meshlink {
         */
        typedef void (*channel_receive_cb_t)(mesh *mesh, channel *channel, const void *data, size_t len);
 
+       /// A callback that is called when data can be send on a channel.
+       /** @param mesh         A handle which represents an instance of MeshLink.
+        *  @param channel      A handle for the channel.
+        *  @param len          The maximum length of data that is guaranteed to be accepted by a call to channel_send().
+        */
+       typedef void (*channel_poll_cb_t)(mesh *mesh, channel *channel, size_t len);
+
        /// A class describing a MeshLink node.
        class node: public meshlink_node_t {
        };
@@ -88,7 +95,7 @@ namespace meshlink {
        /// A class describing a MeshLink mesh.
        class mesh: public meshlink_handle_t {
        public:
-               mesh() {}
+               mesh() : meshlink_handle_t() {}
        
                virtual ~mesh() {
                        meshlink_close(this);
@@ -288,10 +295,25 @@ namespace meshlink {
                 *  @param channel   A handle for the channel.
                 *  @param cb        A pointer to the function which will be called when another node sends data to the local node.
                 */
-               void set_channel_accept_cb(channel *channel, channel_accept_cb_t cb) {
+               void set_channel_accept_cb(channel_accept_cb_t cb) {
                        return meshlink_set_channel_accept_cb(this, (meshlink_channel_accept_cb_t)cb);
                }
 
+               /// Set the poll callback.
+               /** This functions sets the callback that is called whenever data can be sent to another node.
+                *  The callback is run in MeshLink's own thread.
+                *  It is therefore important that the callback uses apprioriate methods (queues, pipes, locking, etc.)
+                *  to pass data to or from the application's thread.
+                *  The callback should also not block itself and return as quickly as possible.
+                *
+                *  @param channel   A handle for the channel.
+                *  @param cb        A pointer to the function which will be called when data can be sent to another node.
+                *                   If a NULL pointer is given, the callback will be disabled.
+                */
+               void set_channel_poll_cb(channel *channel, channel_poll_cb_t cb) {
+                       return meshlink_set_channel_poll_cb(this, channel, (meshlink_channel_poll_cb_t)cb);
+               }
+
                /// Open a reliable stream channel to another node.
                /** This function is called whenever a remote node wants to open a channel to the local node.
                 *  The application then has to decide whether to accept or reject this channel.
@@ -381,12 +403,14 @@ namespace meshlink {
         *
         *  @param confbase The directory in which MeshLink will store its configuration files.
         *  @param name     The name which this instance of the application will use in the mesh.
+        *  @param appname  The application name which will be used in the mesh.
+        *  @param dclass   The device class which will be used in the mesh.
         *
         *  @return         This function will return a pointer to a meshlink::mesh if MeshLink has succesfully set up its configuration files, NULL otherwise.
         */
        template<class MESH>
-       static MESH* open(const char *confbase, const char *name) {
-               void* mp = (void *)meshlink_open_with_size(confbase, name, sizeof(MESH));
+       static MESH* open(const char *confbase, const char *name, const char* appname, dev_class_t devclass) {
+               void* mp = (void *)meshlink_open_with_size(confbase, name, appname, devclass, sizeof(MESH));
                return new (mp) MESH;
        }