added wiki_example and needed library files

lib/c/labcomm_fd_reader_writer.c

+#include <errno.h>
+#include <unistd.h>
+#include "labcomm.h"
+
+#define BUFFER_SIZE 2048
+
+int labcomm_fd_reader(
+  labcomm_reader_t *r, 
+  labcomm_reader_action_t action)
+{
+  int result = -EINVAL;
+  int *fd = r->context;
+  
+  switch (action) {
+    case labcomm_reader_alloc: {
+      r->data = malloc(BUFFER_SIZE);
+      if (r->data) {
+        r->data_size = BUFFER_SIZE;
+        result = r->data_size;
+      } else {
+        r->data_size = 0;
+        result = -ENOMEM;
+      }
+      r->count = 0;
+      r->pos = 0;
+    } break;
+    case labcomm_reader_start: 
+    case labcomm_reader_continue: {
+      if (r->pos < r->count) {
+        result = r->count - r->pos;
+      } else {
+        int err;
+
+        r->pos = 0;
+        err = read(*fd, r->data, r->data_size);
+        if (err <= 0) {
+          r->count = 0;
+          result = -1;
+        } else {
+          r->count = err;
+          result = r->count - r->pos;
+        }
+      }
+    } break;
+    case labcomm_reader_end: {
+      result = 0;
+    } break;
+    case labcomm_reader_free: {
+      free(r->data);
+      r->data = 0;
+      r->data_size = 0;
+      r->count = 0;
+      r->pos = 0;
+      result = 0;
+    } break;
+  }
+  return result;
+}
+
+int labcomm_fd_writer(
+  labcomm_writer_t *w, 
+  labcomm_writer_action_t action)
+{
+  int result = 0;
+  int *fd = w->context;
+
+  switch (action) {
+    case labcomm_writer_alloc: {
+      w->data = malloc(BUFFER_SIZE);
+      if (! w->data) {
+        result = -ENOMEM;
+        w->data_size = 0;
+        w->count = 0;
+        w->pos = 0;
+      } else {
+        w->data_size = BUFFER_SIZE;
+        w->count = BUFFER_SIZE;
+        w->pos = 0;
+      }
+    } break;
+    case labcomm_writer_free: {
+      free(w->data);
+      w->data = 0;
+      w->data_size = 0;
+      w->count = 0;
+      w->pos = 0;
+    } break;
+    case labcomm_writer_start: {
+      w->pos = 0;
+    } break;
+    case labcomm_writer_continue: {
+      result = write(*fd, w->data, w->pos);
+      w->pos = 0;
+    } break;
+    case labcomm_writer_end: {
+      result = write(*fd, w->data, w->pos);
+      w->pos = 0;
+    } break;
+    case labcomm_writer_available: {
+      result = w->count - w->pos; 
+    } break;
+  }
+  return result;
+}

lib/c/labcomm_fd_reader_writer.h

+#include "labcomm.h"
+
+extern int labcomm_fd_reader(
+  labcomm_reader_t *r, 
+  labcomm_reader_action_t action);
+
+extern int labcomm_fd_writer(
+  labcomm_writer_t *r, 
+  labcomm_writer_action_t action);

wiki_example/data.java

+/* 
+sample float data;
+*/
+import java.io.IOException;
+import se.lth.control.labcomm.LabCommDecoder;
+import se.lth.control.labcomm.LabCommDispatcher;
+import se.lth.control.labcomm.LabCommEncoder;
+import se.lth.control.labcomm.LabCommHandler;
+import se.lth.control.labcomm.LabCommSample;
+
+public class data implements LabCommSample {
+
+  public interface Handler extends LabCommHandler {
+    public void handle_data(float value) throws Exception;
+  }
+  
+  public static void register(LabCommDecoder d, Handler h) throws IOException {
+    d.register(new Dispatcher(), h);
+  }
+  
+  public static void register(LabCommEncoder e) throws IOException {
+    e.register(new Dispatcher());
+  }
+  
+  private static class Dispatcher implements LabCommDispatcher {
+    
+    public Class getSampleClass() {
+      return data.class;
+    }
+    
+    public String getName() {
+      return "data";
+    }
+    
+    public byte[] getSignature() {
+      return signature;
+    }
+    
+    public void decodeAndHandle(LabCommDecoder d,
+                                LabCommHandler h) throws Exception {
+      ((Handler)h).handle_data(data.decode(d));
+    }
+    
+  }
+  
+  public static void encode(LabCommEncoder e, float value) throws IOException {
+    e.begin(data.class);
+    e.encodeFloat(value);
+    e.end(data.class);
+  }
+  
+  public static float decode(LabCommDecoder d) throws IOException {
+    float result;
+    result = d.decodeFloat();
+    return result;
+  }
+  
+  private static byte[] signature = new byte[] {
+    0, 0, 0, 37, 
+  };
+
+}

wiki_example/example.c

+#include "labcomm.h"
+#include "labcomm_private.h"
+#include "example.h"
+
+static unsigned char signature_bytes_log_message[] = {
+// struct { 2 fields
+0, 0, 0, 17, 
+  0, 0, 0, 2, 
+  // int 'sequence'
+  0, 0, 0, 8, 
+  115, 101, 113, 117, 101, 110, 99, 101, 
+  0, 0, 0, 35, 
+  // array [_] 'line'
+  0, 0, 0, 4, 
+  108, 105, 110, 101, 
+  // array [_]
+  0, 0, 0, 16, 
+    0, 0, 0, 1, 
+    0, 0, 0, 0, 
+    // struct { 2 fields
+    0, 0, 0, 17, 
+      0, 0, 0, 2, 
+      // boolean 'last'
+      0, 0, 0, 4, 
+      108, 97, 115, 116, 
+      0, 0, 0, 32, 
+      // string 'data'
+      0, 0, 0, 4, 
+      100, 97, 116, 97, 
+      0, 0, 0, 39, 
+    // }
+  // }
+// }
+};
+labcomm_signature_t labcomm_signature_example_log_message = {
+  LABCOMM_SAMPLE, "log_message",
+  (int (*)(void *))labcomm_sizeof_example_log_message,
+  sizeof(signature_bytes_log_message),
+  signature_bytes_log_message
+ };
+static unsigned char signature_bytes_data[] = {
+0, 0, 0, 37, 
+};
+labcomm_signature_t labcomm_signature_example_data = {
+  LABCOMM_SAMPLE, "data",
+  (int (*)(void *))labcomm_sizeof_example_data,
+  sizeof(signature_bytes_data),
+  signature_bytes_data
+ };
+static void decode_log_message(
+  labcomm_decoder_t *d,
+  void (*handle)(
+    example_log_message *v,
+    void *context
+  ),
+  void *context
+)
+{
+  example_log_message v;
+  v.sequence = labcomm_decode_int(d);
+  v.line.n_0 = labcomm_decode_int(d);
+  v.line.a = malloc(sizeof(v.line.a[0]) * v.line.n_0);
+  {
+    int i_0_0;
+    for (i_0_0 = 0 ; i_0_0 < v.line.n_0 ; i_0_0++) {
+      int i_0 = i_0_0;
+      v.line.a[i_0].last = labcomm_decode_boolean(d);
+      v.line.a[i_0].data = labcomm_decode_string(d);
+    }
+  }
+  handle(&v, context);
+  {
+    {
+      int i_0_0;
+      for (i_0_0 = 0 ; i_0_0 < v.line.n_0 ; i_0_0++) {
+        int i_0 = i_0_0;
+        free(v.line.a[i_0].data);
+      }
+    }
+    free(v.line.a);
+  }
+}
+void labcomm_decoder_register_example_log_message(
+  struct labcomm_decoder *d,
+  void (*handler)(
+    example_log_message *v,
+    void *context
+  ),
+  void *context
+)
+{
+  labcomm_internal_decoder_register(
+    d,
+    &labcomm_signature_example_log_message,
+    (labcomm_decoder_typecast_t)decode_log_message,
+    (labcomm_handler_typecast_t)handler,
+    context
+  );
+}
+static void encode_log_message(
+  labcomm_encoder_t *e,
+  example_log_message *v
+)
+{
+  e->writer.write(&e->writer, labcomm_writer_start);
+  labcomm_encode_type_index(e, &labcomm_signature_example_log_message);
+  {
+    labcomm_encode_int(e, (*v).sequence);
+    labcomm_encode_int(e, (*v).line.n_0);
+    {
+      int i_0_0;
+      for (i_0_0 = 0 ; i_0_0 < (*v).line.n_0 ; i_0_0++) {
+        int i_0 = i_0_0;
+        labcomm_encode_boolean(e, (*v).line.a[i_0].last);
+        labcomm_encode_string(e, (*v).line.a[i_0].data);
+      }
+    }
+  }
+  e->writer.write(&e->writer, labcomm_writer_end);
+}
+void labcomm_encode_example_log_message(
+labcomm_encoder_t *e,
+example_log_message *v
+)
+{
+labcomm_internal_encode(e, &labcomm_signature_example_log_message, v);
+}
+void labcomm_encoder_register_example_log_message(
+  struct labcomm_encoder *e
+)
+{
+  labcomm_internal_encoder_register(
+    e,
+    &labcomm_signature_example_log_message,
+    (labcomm_encode_typecast_t)encode_log_message
+  );
+}
+int labcomm_sizeof_example_log_message(example_log_message *v)
+{
+  int result = 4;
+  {
+    int i_0_0;
+    for (i_0_0 = 0 ; i_0_0 < (*v).line.n_0 ; i_0_0++) {
+      int i_0 = i_0_0;
+      result += 4 + strlen((*v).line.a[i_0].data);
+      result += 1;
+    }
+  }
+  result += 4;
+  return result;
+}
+static void decode_data(
+  labcomm_decoder_t *d,
+  void (*handle)(
+    example_data *v,
+    void *context
+  ),
+  void *context
+)
+{
+  example_data v;
+  v = labcomm_decode_float(d);
+  handle(&v, context);
+}
+void labcomm_decoder_register_example_data(
+  struct labcomm_decoder *d,
+  void (*handler)(
+    example_data *v,
+    void *context
+  ),
+  void *context
+)
+{
+  labcomm_internal_decoder_register(
+    d,
+    &labcomm_signature_example_data,
+    (labcomm_decoder_typecast_t)decode_data,
+    (labcomm_handler_typecast_t)handler,
+    context
+  );
+}
+static void encode_data(
+  labcomm_encoder_t *e,
+  example_data *v
+)
+{
+  e->writer.write(&e->writer, labcomm_writer_start);
+  labcomm_encode_type_index(e, &labcomm_signature_example_data);
+  {
+    labcomm_encode_float(e, (*v));
+  }
+  e->writer.write(&e->writer, labcomm_writer_end);
+}
+void labcomm_encode_example_data(
+labcomm_encoder_t *e,
+example_data *v
+)
+{
+labcomm_internal_encode(e, &labcomm_signature_example_data, v);
+}
+void labcomm_encoder_register_example_data(
+  struct labcomm_encoder *e
+)
+{
+  labcomm_internal_encoder_register(
+    e,
+    &labcomm_signature_example_data,
+    (labcomm_encode_typecast_t)encode_data
+  );
+}
+int labcomm_sizeof_example_data(example_data *v)
+{
+  return 8;
+}

wiki_example/example.cs

+using System;
+using se.lth.control.labcomm;
+/* 
+sample struct {
+  int sequence;
+  struct {
+    boolean last;
+    string data;
+  } line[_];
+} log_message;
+*/
+
+public class log_message : LabCommSample {
+
+  public static class struct_line {
+    public boolean last;
+    public String data;
+  }
+  
+  public int sequence;
+  public struct_line[] line;
+  
+  public interface Handler : LabCommHandler {
+    void handle(log_message value);
+  }
+  
+  public static void register(LabCommDecoder d, Handler h) {
+    d.register(new Dispatcher(), h);
+  }
+  
+  public static void register(LabCommEncoder e) {
+    e.register(new Dispatcher());
+  }
+  
+  private class Dispatcher : LabCommDispatcher {
+    
+    public Type getSampleClass() {
+      return typeof(log_message);
+    }
+    
+    public String getName() {
+      return "log_message";
+    }
+    
+    public byte[] getSignature() {
+      return signature;
+    }
+    
+    public void decodeAndHandle(LabCommDecoder d, LabCommHandler h) {
+      ((Handler)h).handle(log_message.decode(d));
+    }
+    
+  }
+  
+  public static void encode(LabCommEncoder e, log_message value) {
+    e.begin(typeof(log_message));
+    e.encodeInt(value.sequence);
+    e.encodeInt(value.line.GetLength(0));
+    int i_0_max = value.line.GetLength(0);
+    for (int i_0 = 0 ; i_0 < i_0_max ; i_0++) {
+      e.encodeBoolean(value.line[i_0].last);
+      e.encodeString(value.line[i_0].data);
+    }
+    e.end(typeof(log_message));
+  }
+  
+  public static log_message decode(LabCommDecoder d) {
+    log_message result;
+    result = new log_message();
+    result.sequence = d.decodeInt();
+    {
+      int i_0_max = d.decodeInt();
+      result.line = new struct_line[i_0_max]
+      ;
+      for (int i_0 = 0 ; i_0 < i_0_max ; i_0++) {
+        result.line[i_0] = new struct_line();
+        result.line[i_0].last = d.decodeBoolean();
+        result.line[i_0].data = d.decodeString();
+      }
+    }
+    return result;
+  }
+  
+  private static byte[] signature = new byte[] {
+    // struct { 2 fields
+    0, 0, 0, 17, 
+      0, 0, 0, 2, 
+      // int 'sequence'
+      0, 0, 0, 8, 
+      115, 101, 113, 117, 101, 110, 99, 101, 
+      0, 0, 0, 35, 
+      // array [_] 'line'
+      0, 0, 0, 4, 
+      108, 105, 110, 101, 
+      // array [_]
+      0, 0, 0, 16, 
+        0, 0, 0, 1, 
+        0, 0, 0, 0, 
+        // struct { 2 fields
+        0, 0, 0, 17, 
+          0, 0, 0, 2, 
+          // boolean 'last'
+          0, 0, 0, 4, 
+          108, 97, 115, 116, 
+          0, 0, 0, 32, 
+          // string 'data'
+          0, 0, 0, 4, 
+          100, 97, 116, 97, 
+          0, 0, 0, 39, 
+        // }
+      // }
+    // }
+  };
+
+}
+/* 
+sample float data;
+*/
+
+public class data : LabCommSample {
+
+  public interface Handler : LabCommHandler {
+    void handle(float value);
+  }
+  
+  public static void register(LabCommDecoder d, Handler h) {
+    d.register(new Dispatcher(), h);
+  }
+  
+  public static void register(LabCommEncoder e) {
+    e.register(new Dispatcher());
+  }
+  
+  private class Dispatcher : LabCommDispatcher {
+    
+    public Type getSampleClass() {
+      return typeof(data);
+    }
+    
+    public String getName() {
+      return "data";
+    }
+    
+    public byte[] getSignature() {
+      return signature;
+    }
+    
+    public void decodeAndHandle(LabCommDecoder d, LabCommHandler h) {
+      ((Handler)h).handle(data.decode(d));
+    }
+    
+  }
+  
+  public static void encode(LabCommEncoder e, float value) {
+    e.begin(typeof(data));
+    e.encodeFloat(value);
+    e.end(typeof(data));
+  }
+  
+  public static float decode(LabCommDecoder d) {
+    float result;
+    result = d.decodeFloat();
+    return result;
+  }
+  
+  private static byte[] signature = new byte[] {
+    0, 0, 0, 37, 
+  };
+
+}

wiki_example/example.h

+/* LabComm declarations:
+sample struct {
+  int sequence;
+  struct {
+    boolean last;
+    string data;
+  } line[_];
+} log_message;
+sample float data;
+*/
+
+
+#ifndef __LABCOMM_example_H__
+#define __LABCOMM_example_H__
+
+#include "labcomm.h"
+
+#ifndef PREDEFINED_example_log_message
+typedef struct {
+  int sequence;
+  struct {
+    int n_0;
+    struct {
+      unsigned char last;
+      char* data;
+    } *a;
+  } line;
+} example_log_message;
+#endif
+void labcomm_decoder_register_example_log_message(
+  struct labcomm_decoder *d,
+  void (*handler)(
+    example_log_message *v,
+    void *context
+  ),
+  void *context
+);
+void labcomm_encoder_register_example_log_message(
+  struct labcomm_encoder *e);
+void labcomm_encode_example_log_message(
+  struct labcomm_encoder *e,
+  example_log_message *v
+);
+extern int labcomm_sizeof_example_log_message(example_log_message *v);
+
+#ifndef PREDEFINED_example_data
+typedef float example_data;
+#endif
+void labcomm_decoder_register_example_data(
+  struct labcomm_decoder *d,
+  void (*handler)(
+    example_data *v,
+    void *context
+  ),