xidl-xcdr 0.2.0

A IDL codegen.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

#pragma once

#include <cstddef>
#include <cstdint>

extern "C" {
#include "../xidl_xcdr.h"
}

namespace xidl {
namespace xcdr {

struct Plcdr2Codec {
  typedef FfiPlcdr2Serializer Serializer;
  typedef FfiPlcdr2Deserializer Deserializer;

  static Serializer serializer_new(uint8_t *ptr, std::size_t len) {
    return plcdr2_serializer_new(ptr, len);
  }
  static std::size_t serializer_position(const Serializer *ser) {
    return plcdr2_serializer_position(ser);
  }
  static void serializer_reset(Serializer *ser) {
    plcdr2_serializer_reset(ser);
  }
  static XcdrFfiError write_u8(Serializer *ser, uint8_t v) {
    return plcdr2_serializer_write_u8(ser, v);
  }
  static XcdrFfiError write_i8(Serializer *ser, int8_t v) {
    return plcdr2_serializer_write_i8(ser, v);
  }
  static XcdrFfiError write_bool(Serializer *ser, bool v) {
    return plcdr2_serializer_write_bool(ser, v);
  }
  static XcdrFfiError write_u16(Serializer *ser, uint16_t v) {
    return plcdr2_serializer_write_u16(ser, v);
  }
  static XcdrFfiError write_i16(Serializer *ser, int16_t v) {
    return plcdr2_serializer_write_i16(ser, v);
  }
  static XcdrFfiError write_u32(Serializer *ser, uint32_t v) {
    return plcdr2_serializer_write_u32(ser, v);
  }
  static XcdrFfiError write_i32(Serializer *ser, int32_t v) {
    return plcdr2_serializer_write_i32(ser, v);
  }
  static XcdrFfiError write_u64(Serializer *ser, uint64_t v) {
    return plcdr2_serializer_write_u64(ser, v);
  }
  static XcdrFfiError write_i64(Serializer *ser, int64_t v) {
    return plcdr2_serializer_write_i64(ser, v);
  }
  static XcdrFfiError write_f32(Serializer *ser, float v) {
    return plcdr2_serializer_write_f32(ser, v);
  }
  static XcdrFfiError write_f64(Serializer *ser, double v) {
    return plcdr2_serializer_write_f64(ser, v);
  }
  static XcdrFfiError write_bytes(Serializer *ser, const uint8_t *ptr,
                                  std::size_t len) {
    return plcdr2_serializer_write_bytes(ser, ptr, len);
  }

  static Deserializer deserializer_new(const uint8_t *ptr, std::size_t len) {
    return plcdr2_deserializer_new(ptr, len);
  }
  static std::size_t deserializer_position(const Deserializer *de) {
    return plcdr2_deserializer_position(de);
  }
  static void deserializer_reset(Deserializer *de) {
    plcdr2_deserializer_reset(de);
  }
  static XcdrFfiError read_u8(Deserializer *de, uint8_t *v) {
    return plcdr2_deserializer_read_u8(de, v);
  }
  static XcdrFfiError read_i8(Deserializer *de, int8_t *v) {
    return plcdr2_deserializer_read_i8(de, v);
  }
  static XcdrFfiError read_bool(Deserializer *de, bool *v) {
    return plcdr2_deserializer_read_bool(de, v);
  }
  static XcdrFfiError read_u16(Deserializer *de, uint16_t *v) {
    return plcdr2_deserializer_read_u16_le(de, v);
  }
  static XcdrFfiError read_i16(Deserializer *de, int16_t *v) {
    return plcdr2_deserializer_read_i16_le(de, v);
  }
  static XcdrFfiError read_u32(Deserializer *de, uint32_t *v) {
    return plcdr2_deserializer_read_u32_le(de, v);
  }
  static XcdrFfiError read_i32(Deserializer *de, int32_t *v) {
    return plcdr2_deserializer_read_i32_le(de, v);
  }
  static XcdrFfiError read_u64(Deserializer *de, uint64_t *v) {
    return plcdr2_deserializer_read_u64_le(de, v);
  }
  static XcdrFfiError read_i64(Deserializer *de, int64_t *v) {
    return plcdr2_deserializer_read_i64_le(de, v);
  }
  static XcdrFfiError read_f32(Deserializer *de, float *v) {
    return plcdr2_deserializer_read_f32_le(de, v);
  }
  static XcdrFfiError read_f64(Deserializer *de, double *v) {
    return plcdr2_deserializer_read_f64_le(de, v);
  }
  static XcdrFfiError read_bytes(Deserializer *de, uint8_t *ptr,
                                 std::size_t len) {
    return plcdr2_deserializer_read_bytes(de, ptr, len);
  }
};

} // namespace xcdr
} // namespace xidl