Commit bb636c49 authored by Sven Robertz's avatar Sven Robertz
Browse files

added wiki_example and needed library files

parent e4624ac2
#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;
}
#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);
/*
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,
};
}
#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;
}
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,
};
}
/* 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
),