src/cbor/serialization.c

20 size_t cbor_serialize(const cbor_item_t *item, unsigned char *buffer,
23   switch (cbor_typeof(item)) {
25       return cbor_serialize_uint(item, buffer, buffer_size);
27       return cbor_serialize_negint(item, buffer, buffer_size);
29       return cbor_serialize_bytestring(item, buffer, buffer_size);
31       return cbor_serialize_string(item, buffer, buffer_size);
33       return cbor_serialize_array(item, buffer, buffer_size);
35       return cbor_serialize_map(item, buffer, buffer_size);
37       return cbor_serialize_tag(item, buffer, buffer_size);
39       return cbor_serialize_float_ctrl(item, buffer, buffer_size);
43 /** Largest integer that can be encoded as embedded in the item leading byte. */
46 /** How many bytes will a tag for a nested item of a given `size` take when
61 size_t cbor_serialized_size(const cbor_item_t *item) {
63   switch (cbor_typeof(item)) {
66       switch (cbor_int_get_width(item)) {
68           if (cbor_get_uint8(item) <= kMaxEmbeddedInt) return 1;
81       if (cbor_bytestring_is_definite(item)) {
83             _cbor_encoded_header_size(cbor_bytestring_length(item));
84         if (cbor_bytestring_length(item) == 0) return header_size;
86                                         cbor_bytestring_length(item));
89       cbor_item_t **chunks = cbor_bytestring_chunks_handle(item);
90       for (size_t i = 0; i < cbor_bytestring_chunk_count(item); i++) {
97       if (cbor_string_is_definite(item)) {
99             _cbor_encoded_header_size(cbor_string_length(item));
100         if (cbor_string_length(item) == 0) return header_size;
101         return _cbor_safe_signaling_add(header_size, cbor_string_length(item));
104       cbor_item_t **chunks = cbor_string_chunks_handle(item);
105       for (size_t i = 0; i < cbor_string_chunk_count(item); i++) {
112       size_t array_size = cbor_array_is_definite(item)
113                               ? _cbor_encoded_header_size(cbor_array_size(item))
115       cbor_item_t **items = cbor_array_handle(item);
116       for (size_t i = 0; i < cbor_array_size(item); i++) {
123       size_t map_size = cbor_map_is_definite(item)
124                             ? _cbor_encoded_header_size(cbor_map_size(item))
126       struct cbor_pair *items = cbor_map_handle(item);
127       for (size_t i = 0; i < cbor_map_size(item); i++) {
137           _cbor_encoded_header_size(cbor_tag_value(item)),
138           cbor_serialized_size(cbor_move(cbor_tag_item(item))));
141       switch (cbor_float_get_width(item)) {
143           return _cbor_encoded_header_size(cbor_ctrl_value(item));
154 size_t cbor_serialize_alloc(const cbor_item_t *item, unsigned char **buffer,
157   size_t serialized_size = cbor_serialized_size(item);
168   size_t written = cbor_serialize(item, *buffer, serialized_size);
174 size_t cbor_serialize_uint(const cbor_item_t *item, unsigned char *buffer,
176   CBOR_ASSERT(cbor_isa_uint(item));
178   switch (cbor_int_get_width(item)) {
180       return cbor_encode_uint8(cbor_get_uint8(item), buffer, buffer_size);
182       return cbor_encode_uint16(cbor_get_uint16(item), buffer, buffer_size);
184       return cbor_encode_uint32(cbor_get_uint32(item), buffer, buffer_size);
186       return cbor_encode_uint64(cbor_get_uint64(item), buffer, buffer_size);
190 size_t cbor_serialize_negint(const cbor_item_t *item, unsigned char *buffer,
192   CBOR_ASSERT(cbor_isa_negint(item));
194   switch (cbor_int_get_width(item)) {
196       return cbor_encode_negint8(cbor_get_uint8(item), buffer, buffer_size);
198       return cbor_encode_negint16(cbor_get_uint16(item), buffer, buffer_size);
200       return cbor_encode_negint32(cbor_get_uint32(item), buffer, buffer_size);
202       return cbor_encode_negint64(cbor_get_uint64(item), buffer, buffer_size);
206 size_t cbor_serialize_bytestring(const cbor_item_t *item, unsigned char *buffer,
208   CBOR_ASSERT(cbor_isa_bytestring(item));
209   if (cbor_bytestring_is_definite(item)) {
210     size_t length = cbor_bytestring_length(item);
213       memcpy(buffer + written, cbor_bytestring_handle(item), length);
218     CBOR_ASSERT(cbor_bytestring_is_indefinite(item));
219     size_t chunk_count = cbor_bytestring_chunk_count(item);
223     cbor_item_t **chunks = cbor_bytestring_chunks_handle(item);
238 size_t cbor_serialize_string(const cbor_item_t *item, unsigned char *buffer,
240   CBOR_ASSERT(cbor_isa_string(item));
241   if (cbor_string_is_definite(item)) {
242     size_t length = cbor_string_length(item);
245       memcpy(buffer + written, cbor_string_handle(item), length);
250     CBOR_ASSERT(cbor_string_is_indefinite(item));
251     size_t chunk_count = cbor_string_chunk_count(item);
255     cbor_item_t **chunks = cbor_string_chunks_handle(item);
270 size_t cbor_serialize_array(const cbor_item_t *item, unsigned char *buffer,
272   CBOR_ASSERT(cbor_isa_array(item));
273   size_t size = cbor_array_size(item), written = 0;
274   cbor_item_t **handle = cbor_array_handle(item);
275   if (cbor_array_is_definite(item)) {
278     CBOR_ASSERT(cbor_array_is_indefinite(item));
290   if (cbor_array_is_definite(item)) {
293     CBOR_ASSERT(cbor_array_is_indefinite(item));
301 size_t cbor_serialize_map(const cbor_item_t *item, unsigned char *buffer,
303   CBOR_ASSERT(cbor_isa_map(item));
304   size_t size = cbor_map_size(item), written = 0;
305   struct cbor_pair *handle = cbor_map_handle(item);
307   if (cbor_map_is_definite(item)) {
310     CBOR_ASSERT(cbor_map_is_indefinite(item));
328   if (cbor_map_is_definite(item)) {
331     CBOR_ASSERT(cbor_map_is_indefinite(item));
339 size_t cbor_serialize_tag(const cbor_item_t *item, unsigned char *buffer,
341   CBOR_ASSERT(cbor_isa_tag(item));
342   size_t written = cbor_encode_tag(cbor_tag_value(item), buffer, buffer_size);
345   size_t item_written = cbor_serialize(cbor_move(cbor_tag_item(item)),
351 size_t cbor_serialize_float_ctrl(const cbor_item_t *item, unsigned char *buffer,
353   CBOR_ASSERT(cbor_isa_float_ctrl(item));
355   switch (cbor_float_get_width(item)) {
358       return cbor_encode_ctrl(cbor_ctrl_value(item), buffer, buffer_size);
360       return cbor_encode_half(cbor_float_get_float2(item), buffer, buffer_size);
362       return cbor_encode_single(cbor_float_get_float4(item), buffer,
365       return cbor_encode_double(cbor_float_get_float8(item), buffer,