diff --git a/docs/api.rst b/docs/api.rst index e61469003..5281902d1 100644 --- a/docs/api.rst +++ b/docs/api.rst @@ -459,3 +459,69 @@ Primitives .. autocfunction:: primitives.h::zp_send_keep_alive .. autocfunction:: primitives.h::zp_send_join_options_default .. autocfunction:: primitives.h::zp_send_join +.. autocfunction:: encoding.h::z_encoding_zenoh_bytes +.. autocfunction:: encoding.h::z_encoding_zenoh_int8 +.. autocfunction:: encoding.h::z_encoding_zenoh_int16 +.. autocfunction:: encoding.h::z_encoding_zenoh_int32 +.. autocfunction:: encoding.h::z_encoding_zenoh_int64 +.. autocfunction:: encoding.h::z_encoding_zenoh_int128 +.. autocfunction:: encoding.h::z_encoding_zenoh_uint8 +.. autocfunction:: encoding.h::z_encoding_zenoh_uint16 +.. autocfunction:: encoding.h::z_encoding_zenoh_uint32 +.. autocfunction:: encoding.h::z_encoding_zenoh_uint64 +.. autocfunction:: encoding.h::z_encoding_zenoh_uint128 +.. autocfunction:: encoding.h::z_encoding_zenoh_float32 +.. autocfunction:: encoding.h::z_encoding_zenoh_float64 +.. autocfunction:: encoding.h::z_encoding_zenoh_bool +.. autocfunction:: encoding.h::z_encoding_zenoh_string +.. autocfunction:: encoding.h::z_encoding_zenoh_error +.. autocfunction:: encoding.h::z_encoding_application_octet_stream +.. autocfunction:: encoding.h::z_encoding_text_plain +.. autocfunction:: encoding.h::z_encoding_application_json +.. autocfunction:: encoding.h::z_encoding_text_json +.. autocfunction:: encoding.h::z_encoding_application_cdr +.. autocfunction:: encoding.h::z_encoding_application_cbor +.. autocfunction:: encoding.h::z_encoding_application_yaml +.. autocfunction:: encoding.h::z_encoding_text_yaml +.. autocfunction:: encoding.h::z_encoding_text_json5 +.. autocfunction:: encoding.h::z_encoding_application_python_serialized_object +.. autocfunction:: encoding.h::z_encoding_application_protobuf +.. autocfunction:: encoding.h::z_encoding_application_java_serialized_object +.. autocfunction:: encoding.h::z_encoding_application_openmetrics_text +.. autocfunction:: encoding.h::z_encoding_image_png +.. autocfunction:: encoding.h::z_encoding_image_jpeg +.. autocfunction:: encoding.h::z_encoding_image_gif +.. autocfunction:: encoding.h::z_encoding_image_bmp +.. autocfunction:: encoding.h::z_encoding_image_webp +.. autocfunction:: encoding.h::z_encoding_application_xml +.. autocfunction:: encoding.h::z_encoding_application_x_www_form_urlencoded +.. autocfunction:: encoding.h::z_encoding_text_html +.. autocfunction:: encoding.h::z_encoding_text_xml +.. autocfunction:: encoding.h::z_encoding_text_css +.. autocfunction:: encoding.h::z_encoding_text_javascript +.. autocfunction:: encoding.h::z_encoding_text_markdown +.. autocfunction:: encoding.h::z_encoding_text_csv +.. autocfunction:: encoding.h::z_encoding_application_sql +.. autocfunction:: encoding.h::z_encoding_application_coap_payload +.. autocfunction:: encoding.h::z_encoding_application_json_patch_json +.. autocfunction:: encoding.h::z_encoding_application_json_seq +.. autocfunction:: encoding.h::z_encoding_application_jsonpath +.. autocfunction:: encoding.h::z_encoding_application_jwt +.. autocfunction:: encoding.h::z_encoding_application_mp4 +.. autocfunction:: encoding.h::z_encoding_application_soap_xml +.. autocfunction:: encoding.h::z_encoding_application_yang +.. autocfunction:: encoding.h::z_encoding_audio_aac +.. autocfunction:: encoding.h::z_encoding_audio_flac +.. autocfunction:: encoding.h::z_encoding_audio_mp4 +.. autocfunction:: encoding.h::z_encoding_audio_ogg +.. autocfunction:: encoding.h::z_encoding_audio_vorbis +.. autocfunction:: encoding.h::z_encoding_video_h261 +.. autocfunction:: encoding.h::z_encoding_video_h263 +.. autocfunction:: encoding.h::z_encoding_video_h264 +.. autocfunction:: encoding.h::z_encoding_video_h265 +.. autocfunction:: encoding.h::z_encoding_video_h266 +.. autocfunction:: encoding.h::z_encoding_video_mp4 +.. autocfunction:: encoding.h::z_encoding_video_ogg +.. autocfunction:: encoding.h::z_encoding_video_raw +.. autocfunction:: encoding.h::z_encoding_video_vp8 +.. autocfunction:: encoding.h::z_encoding_video_vp9 diff --git a/docs/conf.py b/docs/conf.py index 4ad571076..1cf877a6e 100644 --- a/docs/conf.py +++ b/docs/conf.py @@ -35,6 +35,7 @@ "-DZ_FEATURE_SUBSCRIPTION=1", "-DZ_FEATURE_QUERY=1", "-DZ_FEATURE_QUERYABLE=1", + "-DZ_FEATURE_ENCODING_VALUES=1" ] # -- Options for HTML output ------------------------------------------------- diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index a0476703f..a3fc911cd 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -54,6 +54,7 @@ if(UNIX) add_example(z_pong unix/c11/z_pong.c) add_example(z_pub_thr unix/c11/z_pub_thr.c) add_example(z_sub_thr unix/c11/z_sub_thr.c) + add_example(z_bytes unix/c11/z_bytes.c) endif() elseif(MSVC) add_example(z_put windows/z_put.c) diff --git a/examples/unix/c11/z_bytes.c b/examples/unix/c11/z_bytes.c new file mode 100644 index 000000000..a5a074b02 --- /dev/null +++ b/examples/unix/c11/z_bytes.c @@ -0,0 +1,205 @@ +// +// Copyright (c) 2024 ZettaScale Technology +// +// This program and the accompanying materials are made available under the +// terms of the Eclipse Public License 2.0 which is available at +// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 +// which is available at https://www.apache.org/licenses/LICENSE-2.0. +// +// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 +// +// Contributors: +// ZettaScale Zenoh Team, +// + +#include +#include +#include +#include +#include +#include +#include + +#undef NDEBUG +#include + +#include "zenoh-pico/system/platform.h" + +typedef struct kv_pair_t { + const char *key; + const char *value; +} kv_pair_t; + +typedef struct kv_pairs_tx_t { + const kv_pair_t *data; + uint32_t len; + uint32_t current_idx; +} kv_pairs_tx_t; + +typedef struct kv_pair_decoded_t { + z_owned_string_t key; + z_owned_string_t value; +} kv_pair_decoded_t; + +typedef struct kv_pairs_rx_t { + kv_pair_decoded_t *data; + uint32_t len; + uint32_t current_idx; +} kv_pairs_rx_t; + +static bool hashmap_iter(z_owned_bytes_t *kv_pair, void *context); +static bool iter_body(z_owned_bytes_t *b, void *context); +static void parse_hashmap(kv_pairs_rx_t *kvp, const z_loaned_bytes_t *hashmap); +static void drop_hashmap(kv_pairs_rx_t *kvp); +static void print_slice_data(z_view_slice_t *slice); + +int main(void) { + // z_owned_encoding_t encoding; + z_owned_bytes_t payload; + + // Number types: uint8, uint16, uint32, uint64, int8, int16, int32, int64, float, double + uint32_t input_u32 = 123456; + uint32_t output_u32 = 0; + z_bytes_serialize_from_uint32(&payload, input_u32); + z_bytes_deserialize_into_uint32(z_loan(payload), &output_u32); + assert(input_u32 == output_u32); + z_drop(z_move(payload)); + // Corresponding encoding to be used in operations options like `z_put()`, `z_get()`, etc. + // encoding = ZP_ENCODING_ZENOH_UINT32; + + // String, also work with and z_owned_string_t + const char *input_str = "test"; + z_owned_string_t output_string; + z_bytes_serialize_from_str(&payload, input_str); + z_bytes_deserialize_into_string(z_loan(payload), &output_string); + assert(strncmp(input_str, z_string_data(z_loan(output_string)), strlen(input_str)) == 0); + z_drop(z_move(payload)); + z_drop(z_move(output_string)); + // Corresponding encoding to be used in operations options like `z_put()`, `z_get()`, etc. + // encoding = ZP_ENCODING_ZENOH_STRING; + + // Bytes, also work with z_owned_slice_t + const uint8_t input_bytes[] = {1, 2, 3, 4}; + z_owned_slice_t output_bytes; + z_bytes_serialize_from_buf(&payload, input_bytes, sizeof(input_bytes)); + z_bytes_deserialize_into_slice(z_loan(payload), &output_bytes); + assert(memcmp(input_bytes, z_slice_data(z_loan(output_bytes)), sizeof(input_bytes)) == 0); + z_drop(z_move(payload)); + z_drop(z_move(output_bytes)); + // Corresponding encoding to be used in operations options like `z_put()`, `z_get()`, etc. + // encoding = ZP_ENCODING_ZENOH_BYTES; // That's the default value + + // Writer reader + uint8_t input_writer[] = {0, 1, 2, 3, 4}; + uint8_t output_reader[5] = {0}; + z_bytes_empty(&payload); + z_bytes_writer_t writer = z_bytes_get_writer(z_bytes_loan_mut(&payload)); + z_bytes_writer_write_all(&writer, input_writer, 3); + z_bytes_writer_write_all(&writer, input_writer + 3, 2); + z_bytes_reader_t reader = z_bytes_get_reader(z_bytes_loan(&payload)); + z_bytes_reader_read(&reader, output_reader, sizeof(output_reader)); + assert(0 == memcmp(input_writer, output_reader, sizeof(output_reader))); + z_drop(z_move(payload)); + + // Bytes iterator + uint8_t result_iter[] = {0, 1, 2, 3, 4}; + uint8_t output_iter[5] = {0}; + uint8_t context = 0; + z_bytes_from_iter(&payload, iter_body, (void *)(&context)); + z_bytes_iterator_t it = z_bytes_get_iterator(z_bytes_loan(&payload)); + + z_owned_bytes_t current_item; + size_t i = 0; + while (z_bytes_iterator_next(&it, ¤t_item)) { + z_bytes_deserialize_into_uint8(z_bytes_loan(¤t_item), &output_reader[i]); + z_bytes_drop(z_bytes_move(¤t_item)); + i++; + } + assert(memcmp(output_iter, result_iter, sizeof(output_iter))); + z_drop(z_move(payload)); + + // Hash map + kv_pair_t input_hashmap[1]; + input_hashmap[0] = (kv_pair_t){.key = "test_key", .value = "test_value"}; + kv_pairs_tx_t ctx = (kv_pairs_tx_t){.data = input_hashmap, .current_idx = 0, .len = 1}; + z_bytes_from_iter(&payload, hashmap_iter, (void *)&ctx); + kv_pairs_rx_t output_hashmap = { + .current_idx = 0, .len = 16, .data = (kv_pair_decoded_t *)malloc(16 * sizeof(kv_pair_decoded_t))}; + parse_hashmap(&output_hashmap, z_loan(payload)); + assert(strncmp(input_hashmap[0].key, _z_string_data(z_loan(output_hashmap.data[0].key)), + strlen(input_hashmap[0].key)) == 0); + assert(strncmp(input_hashmap[0].value, _z_string_data(z_loan(output_hashmap.data[0].value)), + strlen(input_hashmap[0].value)) == 0); + z_drop(z_move(payload)); + drop_hashmap(&output_hashmap); + + // Slice iterator + kv_pair_t input_val[1]; + input_val[0] = (kv_pair_t){.key = "test_key", .value = "test_value"}; + ctx = (kv_pairs_tx_t){.data = input_val, .current_idx = 0, .len = 1}; + z_bytes_from_iter(&payload, hashmap_iter, (void *)&ctx); + z_bytes_slice_iterator_t slice_iter = z_bytes_get_slice_iterator(z_bytes_loan(&payload)); + z_view_slice_t curr_slice; + while (z_bytes_slice_iterator_next(&slice_iter, &curr_slice)) { + printf("slice len: %d, slice data: '", (int)z_slice_len(z_view_slice_loan(&curr_slice))); + print_slice_data(&curr_slice); + printf("'\n"); + } + z_drop(z_move(payload)); + + return 0; +} + +static bool iter_body(z_owned_bytes_t *b, void *context) { + uint8_t *val = (uint8_t *)context; + if (*val >= 5) { + return false; + } else { + z_bytes_serialize_from_uint8(b, *val); + } + *val = *val + 1; + return true; +} + +static bool hashmap_iter(z_owned_bytes_t *kv_pair, void *context) { + kv_pairs_tx_t *kvs = (kv_pairs_tx_t *)(context); + z_owned_bytes_t k, v; + if (kvs->current_idx >= kvs->len) { + return false; + } else { + z_bytes_serialize_from_str(&k, kvs->data[kvs->current_idx].key); + z_bytes_serialize_from_str(&v, kvs->data[kvs->current_idx].value); + z_bytes_from_pair(kv_pair, z_move(k), z_move(v)); + kvs->current_idx++; + return true; + } +} + +static void parse_hashmap(kv_pairs_rx_t *kvp, const z_loaned_bytes_t *hashmap) { + z_owned_bytes_t kv, first, second; + z_bytes_iterator_t iter = z_bytes_get_iterator(hashmap); + + while (kvp->current_idx < kvp->len && z_bytes_iterator_next(&iter, &kv)) { + z_bytes_deserialize_into_pair(z_loan(kv), &first, &second); + z_bytes_deserialize_into_string(z_loan(first), &kvp->data[kvp->current_idx].key); + z_bytes_deserialize_into_string(z_loan(second), &kvp->data[kvp->current_idx].value); + z_bytes_drop(z_bytes_move(&first)); + z_bytes_drop(z_bytes_move(&second)); + z_bytes_drop(z_bytes_move(&kv)); + kvp->current_idx++; + } +} + +static void drop_hashmap(kv_pairs_rx_t *kvp) { + for (size_t i = 0; i < kvp->current_idx; i++) { + z_string_drop(z_string_move(&kvp->data[i].key)); + z_string_drop(z_string_move(&kvp->data[i].value)); + } + z_free(kvp->data); +} + +static void print_slice_data(z_view_slice_t *slice) { + for (size_t i = 0; i < z_slice_len(z_view_slice_loan(slice)); i++) { + printf("0x%02x ", z_slice_data(z_view_slice_loan(slice))[i]); + } +} diff --git a/include/zenoh-pico.h b/include/zenoh-pico.h index a41138ff3..b34291ca4 100644 --- a/include/zenoh-pico.h +++ b/include/zenoh-pico.h @@ -24,6 +24,7 @@ #define ZENOH_PICO_TWEAK 0 #include "zenoh-pico/api/constants.h" +#include "zenoh-pico/api/encoding.h" #include "zenoh-pico/api/handlers.h" #include "zenoh-pico/api/macros.h" #include "zenoh-pico/api/primitives.h" diff --git a/include/zenoh-pico.h.in b/include/zenoh-pico.h.in index 1db75cd76..bd4790b1e 100644 --- a/include/zenoh-pico.h.in +++ b/include/zenoh-pico.h.in @@ -24,6 +24,7 @@ #define ZENOH_PICO_TWEAK @ZENOH_PICO_TWEAK@ #include "zenoh-pico/api/constants.h" +#include "zenoh-pico/api/encoding.h" #include "zenoh-pico/api/handlers.h" #include "zenoh-pico/api/macros.h" #include "zenoh-pico/api/primitives.h" diff --git a/include/zenoh-pico/api/constants.h b/include/zenoh-pico/api/constants.h index d91fc3441..d2c623e4c 100644 --- a/include/zenoh-pico/api/constants.h +++ b/include/zenoh-pico/api/constants.h @@ -109,93 +109,6 @@ typedef enum { typedef enum { Z_SAMPLE_KIND_PUT = 0, Z_SAMPLE_KIND_DELETE = 1 } z_sample_kind_t; #define Z_SAMPLE_KIND_DEFAULT Z_SAMPLE_KIND_PUT -/** - * Default encoding values used by Zenoh. - * - * An encoding has a similar role to Content-type in HTTP: it indicates, when present, how data should be interpreted by - * the application. - * - * Please note the Zenoh protocol does not impose any encoding value nor it operates on it. - * It can be seen as some optional metadata that is carried over by Zenoh in such a way the application may perform - * different operations depending on the encoding value. - * - * A set of associated constants are provided to cover the most common encodings for user convenience. - * This is particularly useful in helping Zenoh to perform additional wire-level optimizations. - * - * Register your encoding metadata from a string with :c:func:`z_encoding_from_str`. To get the optimization, you need - * Z_FEATURE_ENCODING_VALUES to 1 and your string should follow the format: ";" - * - * E.g: "text/plain;utf8" - * - * Here is the list of constants: - */ -// "zenoh/bytes" -// "zenoh/int8" -// "zenoh/int16" -// "zenoh/int32" -// "zenoh/int64" -// "zenoh/int128" -// "zenoh/uint8" -// "zenoh/uint16" -// "zenoh/uint32" -// "zenoh/uint64" -// "zenoh/uint128" -// "zenoh/float32" -// "zenoh/float64" -// "zenoh/bool" -// "zenoh/string" -// "zenoh/error" -// "application/octet-stream" -// "text/plain" -// "application/json" -// "text/json" -// "application/cdr" -// "application/cbor" -// "application/yaml" -// "text/yaml" -// "text/json5" -// "application/python-serialized-object" -// "application/protobuf" -// "application/java-serialized-object" -// "application/openmetrics-text" -// "image/png" -// "image/jpeg" -// "image/gif" -// "image/bmp" -// "image/webp" -// "application/xml" -// "application/x-www-form-urlencoded" -// "text/html" -// "text/xml" -// "text/css" -// "text/javascript" -// "text/markdown" -// "text/csv" -// "application/sql" -// "application/coap-payload" -// "application/json-patch+json" -// "application/json-seq" -// "application/jsonpath" -// "application/jwt" -// "application/mp4" -// "application/soap+xml" -// "application/yang" -// "audio/aac" -// "audio/flac" -// "audio/mp4" -// "audio/ogg" -// "audio/vorbis" -// "video/h261" -// "video/h263" -// "video/h264" -// "video/h265" -// "video/h266" -// "video/mp4" -// "video/ogg" -// "video/raw" -// "video/vp8" -// "video/vp9" - /** * Consolidation mode values. * diff --git a/include/zenoh-pico/api/encoding.h b/include/zenoh-pico/api/encoding.h new file mode 100644 index 000000000..0e46f4f46 --- /dev/null +++ b/include/zenoh-pico/api/encoding.h @@ -0,0 +1,543 @@ +// +// Copyright (c) 2024 ZettaScale Technology +// +// This program and the accompanying materials are made available under the +// terms of the Eclipse Public License 2.0 which is available at +// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 +// which is available at https://www.apache.org/licenses/LICENSE-2.0. +// +// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 +// +// Contributors: +// ZettaScale Zenoh Team, + +#ifndef ZENOH_PICO_API_ENCODING_H +#define ZENOH_PICO_API_ENCODING_H + +#include "zenoh-pico/api/types.h" + +#ifdef __cplusplus +extern "C" { +#endif +/** + * Default encoding values used by Zenoh. + * + * An encoding has a similar role to Content-type in HTTP: it indicates, when present, how data should be interpreted by + * the application. + * + * Please note the Zenoh protocol does not impose any encoding value nor it operates on it. + * It can be seen as some optional metadata that is carried over by Zenoh in such a way the application may perform + * different operations depending on the encoding value. + * + * A set of associated constants are provided to cover the most common encodings for user convenience. + * This is particularly useful in helping Zenoh to perform additional wire-level optimizations. + * + * Register your encoding metadata from a string with :c:func:`z_encoding_from_str`. To get the optimization, you need + * Z_FEATURE_ENCODING_VALUES to 1 and your string should follow the format: ";" + * + * E.g: "text/plain;utf8" + * + * Or you can set the value to the constants directly with this list of constants: + */ + +#if Z_FEATURE_ENCODING_VALUES == 1 +// - Below are Primitives types, supported in all Zenoh bindings +/** + * Just some bytes. + * + * Constant alias for string: `"zenoh/bytes"`. + * + * Usually used for types: `uint8_t[]`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_bytes(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_BYTES; + +/** + * A VLE-encoded signed little-endian 8bit integer. Binary representation uses two's complement. + * Constant alias for string: `"zenoh/int8"`. + * + * Usually used for types: `int8_t`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_int8(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_INT8; + +/** + * A VLE-encoded signed little-endian 16bit integer. Binary representation uses two's complement. + * Constant alias for string: `"zenoh/int16"`. + * + * Usually used for types: `int16_t`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_int16(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_INT16; + +/** + * A VLE-encoded signed little-endian 32bit integer. Binary representation uses two's complement. + * Constant alias for string: `"zenoh/int32"`. + * + * Usually used for types: `int32_t`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_int32(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_INT32; + +/** + * A VLE-encoded signed little-endian 64bit integer. Binary representation uses two's complement. + * Constant alias for string: `"zenoh/int64"`. + * + * Usually used for types: `int64_t`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_int64(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_INT64; + +/** + * A VLE-encoded signed little-endian 128bit integer. Binary representation uses two's complement. + * Constant alias for string: `"zenoh/int128"`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_int128(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_INT128; + +/** + * A VLE-encoded unsigned little-endian 8bit integer. + * Constant alias for string: `"zenoh/uint8"`. + * + * Usually used for types: `uint8_t`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_uint8(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_UINT8; + +/** + * A VLE-encoded unsigned little-endian 16bit integer. + * Constant alias for string: `"zenoh/uint16"`. + * + * Usually used for types: `uint16_t`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_uint16(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_UINT16; + +/** + * A VLE-encoded unsigned little-endian 32bit integer. + * Constant alias for string: `"zenoh/uint32"`. + * + * Usually used for types: `uint32_t`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_uint32(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_UINT32; + +/** + * A VLE-encoded unsigned little-endian 64bit integer. + * Constant alias for string: `"zenoh/uint64"`. + * + * Usually used for types: `uint64_t`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_uint64(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_UINT64; + +/** + * A VLE-encoded unsigned little-endian 128bit integer. + * Constant alias for string: `"zenoh/uint128"`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_uint128(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_UINT128; + +/** + * A VLE-encoded 32bit float. Binary representation uses *IEEE 754-2008* *binary32*. + * Constant alias for string: `"zenoh/float32"`. + * + * Usually used for types: `float`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_float32(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_FLOAT32; + +/** + * A VLE-encoded 64bit float. Binary representation uses *IEEE 754-2008* *binary64*. + * Constant alias for string: `"zenoh/float64"`. + * + * Usually used for types: `double`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_float64(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_FLOAT64; + +/** + * A boolean. `0` is `false`, `1` is `true`. Other values are invalid. + * Constant alias for string: `"zenoh/bool"`. + * + * Usually used for types: `bool`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_bool(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_BOOL; + +/** + * A UTF-8 string. + * Constant alias for string: `"zenoh/string"`. + * + * Usually used for types: `char[]`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_string(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_STRING; + +/** + * A zenoh error. + * Constant alias for string: `"zenoh/error"`. + * + * Usually used for types: `z_reply_err_t`. + */ +const z_loaned_encoding_t *z_encoding_zenoh_error(void); +extern const z_owned_encoding_t ZP_ENCODING_ZENOH_ERROR; + +/** + * An application-specific stream of bytes. + * Constant alias for string: `"application/octet-stream"`. + */ +const z_loaned_encoding_t *z_encoding_application_octet_stream(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_OCTET_STREAM; + +/** + * A textual file. + * Constant alias for string: `"text/plain"`. + */ +const z_loaned_encoding_t *z_encoding_text_plain(void); +extern const z_owned_encoding_t ENCODING_TEXT_PLAIN; + +/** + * JSON data intended to be consumed by an application. + * Constant alias for string: `"application/json"`. + */ +const z_loaned_encoding_t *z_encoding_application_json(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_JSON; + +/** + * JSON data intended to be human readable. + * Constant alias for string: `"text/json"`. + */ +const z_loaned_encoding_t *z_encoding_text_json(void); +extern const z_owned_encoding_t ENCODING_TEXT_JSON; + +/** + * A Common Data Representation (CDR)-encoded data. + * Constant alias for string: `"application/cdr"`. + */ +const z_loaned_encoding_t *z_encoding_application_cdr(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_CDR; + +/** + * A Concise Binary Object Representation (CBOR)-encoded data. + * Constant alias for string: `"application/cbor"`. + */ +const z_loaned_encoding_t *z_encoding_application_cbor(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_CBOR; + +/** + * YAML data intended to be consumed by an application. + * Constant alias for string: `"application/yaml"`. + */ +const z_loaned_encoding_t *z_encoding_application_yaml(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_YAML; + +/** + * YAML data intended to be human readable. + * Constant alias for string: `"text/yaml"`. + */ +const z_loaned_encoding_t *z_encoding_text_yaml(void); +extern const z_owned_encoding_t ENCODING_TEXT_YAML; + +/** + * JSON5 encoded data that are human readable. + * Constant alias for string: `"text/json5"`. + */ +const z_loaned_encoding_t *z_encoding_text_json5(void); +extern const z_owned_encoding_t ENCODING_TEXT_JSON5; + +/** + * A Python object serialized using [pickle](https://docs.python.org/3/library/pickle.html). + * Constant alias for string: `"application/python-serialized-object"`. + */ +const z_loaned_encoding_t *z_encoding_application_python_serialized_object(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_PYTHON_SERIALIZED_OBJECT; + +/** + * An application-specific protobuf-encoded data. + * Constant alias for string: `"application/protobuf"`. + */ +const z_loaned_encoding_t *z_encoding_application_protobuf(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_PROTOBUF; + +/** + * A Java serialized object. + * Constant alias for string: `"application/java-serialized-object"`. + */ +const z_loaned_encoding_t *z_encoding_application_java_serialized_object(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_JAVA_SERIALIZED_OBJECT; + +/** + * An [openmetrics](https://github.com/OpenObservability/OpenMetrics) data, commonly used by + * [Prometheus](https://prometheus.io/). + * Constant alias for string: `"application/openmetrics-text"`. + */ +const z_loaned_encoding_t *z_encoding_application_openmetrics_text(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_OPENMETRICS_TEXT; + +/** + * A Portable Network Graphics (PNG) image. + * Constant alias for string: `"image/png"`. + */ +const z_loaned_encoding_t *z_encoding_image_png(void); +extern const z_owned_encoding_t ENCODING_IMAGE_PNG; + +/** + * A Joint Photographic Experts Group (JPEG) image. + * Constant alias for string: `"image/jpeg"`. + */ +const z_loaned_encoding_t *z_encoding_image_jpeg(void); +extern const z_owned_encoding_t ENCODING_IMAGE_JPEG; + +/** + * A Graphics Interchange Format (GIF) image. + * Constant alias for string: `"image/gif"`. + */ +const z_loaned_encoding_t *z_encoding_image_gif(void); +extern const z_owned_encoding_t ENCODING_IMAGE_GIF; + +/** + * A BitMap (BMP) image. + * Constant alias for string: `"image/bmp"`. + */ +const z_loaned_encoding_t *z_encoding_image_bmp(void); +extern const z_owned_encoding_t ENCODING_IMAGE_BMP; + +/** + * A Web Portable (WebP) image. + * Constant alias for string: `"image/webp"`. + */ +const z_loaned_encoding_t *z_encoding_image_webp(void); +extern const z_owned_encoding_t ENCODING_IMAGE_WEBP; + +/** + * An XML file intended to be consumed by an application. + * Constant alias for string: `"application/xml"`. + */ +const z_loaned_encoding_t *z_encoding_application_xml(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_XML; + +/** + * An encoded list of tuples, each consisting of a name and a value. + * Constant alias for string: `"application/x-www-form-urlencoded"`. + */ +const z_loaned_encoding_t *z_encoding_application_x_www_form_urlencoded(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_X_WWW_FORM_URLENCODED; + +/** + * An HTML file. + * Constant alias for string: `"text/html"`. + */ +const z_loaned_encoding_t *z_encoding_text_html(void); +extern const z_owned_encoding_t ENCODING_TEXT_HTML; + +/** + * An XML file that is human-readable. + * Constant alias for string: `"text/xml"`. + */ +const z_loaned_encoding_t *z_encoding_text_xml(void); +extern const z_owned_encoding_t ENCODING_TEXT_XML; + +/** + * A CSS file. + * Constant alias for string: `"text/css"`. + */ +const z_loaned_encoding_t *z_encoding_text_css(void); +extern const z_owned_encoding_t ENCODING_TEXT_CSS; + +/** + * A JavaScript file. + * Constant alias for string: `"text/javascript"`. + */ +const z_loaned_encoding_t *z_encoding_text_javascript(void); +extern const z_owned_encoding_t ENCODING_TEXT_JAVASCRIPT; + +/** + * A Markdown file. + * Constant alias for string: `"text/markdown"`. + */ +const z_loaned_encoding_t *z_encoding_text_markdown(void); +extern const z_owned_encoding_t ENCODING_TEXT_MARKDOWN; + +/** + * A CSV file. + * Constant alias for string: `"text/csv"`. + */ +const z_loaned_encoding_t *z_encoding_text_csv(void); +extern const z_owned_encoding_t ENCODING_TEXT_CSV; + +/** + * An application-specific SQL query. + * Constant alias for string: `"application/sql"`. + */ +const z_loaned_encoding_t *z_encoding_application_sql(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_SQL; + +/** + * Constrained Application Protocol (CoAP) data intended for CoAP-to-HTTP and HTTP-to-CoAP proxies. + * Constant alias for string: `"application/coap-payload"`. + */ +const z_loaned_encoding_t *z_encoding_application_coap_payload(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_COAP_PAYLOAD; + +/** + * Defines a JSON document structure for expressing a sequence of operations to apply to a JSON document. + * Constant alias for string: `"application/json-patch+json"`. + */ +const z_loaned_encoding_t *z_encoding_application_json_patch_json(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_JSON_PATCH_JSON; + +/** + * A JSON text sequence consists of any number of JSON texts, all encoded in UTF-8. + * Constant alias for string: `"application/json-seq"`. + */ +const z_loaned_encoding_t *z_encoding_application_json_seq(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_JSON_SEQ; + +/** + * A JSONPath defines a string syntax for selecting and extracting JSON values from within a given JSON value. + * Constant alias for string: `"application/jsonpath"`. + */ +const z_loaned_encoding_t *z_encoding_application_jsonpath(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_JSONPATH; + +/** + * A JSON Web Token (JWT). + * Constant alias for string: `"application/jwt"`. + */ +const z_loaned_encoding_t *z_encoding_application_jwt(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_JWT; + +/** + * An application-specific MPEG-4 encoded data, either audio or video. + * Constant alias for string: `"application/mp4"`. + */ +const z_loaned_encoding_t *z_encoding_application_mp4(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_MP4; + +/** + * A SOAP 1.2 message serialized as XML 1.0. + * Constant alias for string: `"application/soap+xml"`. + */ +const z_loaned_encoding_t *z_encoding_application_soap_xml(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_SOAP_XML; + +/** + * A YANG-encoded data commonly used by the Network Configuration Protocol (NETCONF). + * Constant alias for string: `"application/yang"`. + */ +const z_loaned_encoding_t *z_encoding_application_yang(void); +extern const z_owned_encoding_t ENCODING_APPLICATION_YANG; + +/** + * A MPEG-4 Advanced Audio Coding (AAC) media. + * Constant alias for string: `"audio/aac"`. + */ +const z_loaned_encoding_t *z_encoding_audio_aac(void); +extern const z_owned_encoding_t ENCODING_AUDIO_AAC; + +/** + * A Free Lossless Audio Codec (FLAC) media. + * Constant alias for string: `"audio/flac"`. + */ +const z_loaned_encoding_t *z_encoding_audio_flac(void); +extern const z_owned_encoding_t ENCODING_AUDIO_FLAC; + +/** + * An audio codec defined in MPEG-1, MPEG-2, MPEG-4, or registered at the MP4 registration authority. + * Constant alias for string: `"audio/mp4"`. + */ +const z_loaned_encoding_t *z_encoding_audio_mp4(void); +extern const z_owned_encoding_t ENCODING_AUDIO_MP4; + +/** + * An Ogg-encapsulated audio stream. + * Constant alias for string: `"audio/ogg"`. + */ +const z_loaned_encoding_t *z_encoding_audio_ogg(void); +extern const z_owned_encoding_t ENCODING_AUDIO_OGG; + +/** + * A Vorbis-encoded audio stream. + * Constant alias for string: `"audio/vorbis"`. + */ +const z_loaned_encoding_t *z_encoding_audio_vorbis(void); +extern const z_owned_encoding_t ENCODING_AUDIO_VORBIS; + +/** + * A h261-encoded video stream. + * Constant alias for string: `"video/h261"`. + */ +const z_loaned_encoding_t *z_encoding_video_h261(void); +extern const z_owned_encoding_t ENCODING_VIDEO_H261; + +/** + * A h263-encoded video stream. + * Constant alias for string: `"video/h263"`. + */ +const z_loaned_encoding_t *z_encoding_video_h263(void); +extern const z_owned_encoding_t ENCODING_VIDEO_H263; + +/** + * A h264-encoded video stream. + * Constant alias for string: `"video/h264"`. + */ +const z_loaned_encoding_t *z_encoding_video_h264(void); +extern const z_owned_encoding_t ENCODING_VIDEO_H264; + +/** + * A h265-encoded video stream. + * Constant alias for string: `"video/h265"`. + */ +const z_loaned_encoding_t *z_encoding_video_h265(void); +extern const z_owned_encoding_t ENCODING_VIDEO_H265; + +/** + * A h266-encoded video stream. + * Constant alias for string: `"video/h266"`. + */ +const z_loaned_encoding_t *z_encoding_video_h266(void); +extern const z_owned_encoding_t ENCODING_VIDEO_H266; + +/** + * A video codec defined in MPEG-1, MPEG-2, MPEG-4, or registered at the MP4 registration authority. + * Constant alias for string: `"video/mp4"`. + */ +const z_loaned_encoding_t *z_encoding_video_mp4(void); +extern const z_owned_encoding_t ENCODING_VIDEO_MP4; + +/** + * An Ogg-encapsulated video stream. + * Constant alias for string: `"video/ogg"`. + */ +const z_loaned_encoding_t *z_encoding_video_ogg(void); +extern const z_owned_encoding_t ENCODING_VIDEO_OGG; + +/** + * An uncompressed, studio-quality video stream. + * Constant alias for string: `"video/raw"`. + */ +const z_loaned_encoding_t *z_encoding_video_raw(void); +extern const z_owned_encoding_t ENCODING_VIDEO_RAW; + +/** + * A VP8-encoded video stream. + * Constant alias for string: `"video/vp8"`. + */ +const z_loaned_encoding_t *z_encoding_video_vp8(void); +extern const z_owned_encoding_t ENCODING_VIDEO_VP8; + +/** + * A VP9-encoded video stream. + * Constant alias for string: `"video/vp9"`. + */ +const z_loaned_encoding_t *z_encoding_video_vp9(void); +extern const z_owned_encoding_t ENCODING_VIDEO_VP9; + +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* ZENOH_PICO_API_ENCODING_H */ diff --git a/include/zenoh-pico/api/primitives.h b/include/zenoh-pico/api/primitives.h index b2f37e626..d74daa3d5 100644 --- a/include/zenoh-pico/api/primitives.h +++ b/include/zenoh-pico/api/primitives.h @@ -1673,7 +1673,7 @@ const z_loaned_encoding_t *z_sample_encoding(const z_loaned_sample_t *sample); z_sample_kind_t z_sample_kind(const z_loaned_sample_t *sample); /** - * (unstable) Gets the reliability a sample was received with. + * Gets the reliability a sample was received with (unstable). * * Parameters: * sample: Pointer to a :c:type:`z_loaned_sample_t` to get the reliability from. diff --git a/include/zenoh-pico/api/types.h b/include/zenoh-pico/api/types.h index f1f6ae955..d30e968da 100644 --- a/include/zenoh-pico/api/types.h +++ b/include/zenoh-pico/api/types.h @@ -229,7 +229,7 @@ typedef struct { * publisher. * z_priority_t priority: The priority of messages issued by this publisher. * bool is_express: If true, Zenoh will not wait to batch this operation with others to reduce the bandwidth. - * (unstable) z_reliability_t reliability: The reliability that should be used to transmit the data. + * z_reliability_t reliability: (unstable) The reliability that should be used to transmit the data. */ typedef struct { z_moved_encoding_t *encoding; @@ -309,7 +309,7 @@ typedef struct { * z_timestamp_t *timestamp: The API level timestamp (e.g. of the data when it was created). * bool is_express: If true, Zenoh will not wait to batch this operation with others to reduce the bandwidth. * z_moved_bytes_t* attachment: An optional attachment to the publication. - * (unstable) z_reliability_t reliability: The reliability that should be used to transmit the data. + * z_reliability_t reliability: (unstable) The reliability that should be used to transmit the data. */ typedef struct { z_moved_encoding_t *encoding; @@ -331,7 +331,7 @@ typedef struct { * z_priority_t priority: The priority of this message when router. * bool is_express: If true, Zenoh will not wait to batch this operation with others to reduce the bandwidth. * z_timestamp_t *timestamp: The API level timestamp (e.g. of the data when it was created). - * (unstable) z_reliability_t reliability: The reliability that should be used to transmit the data. + * z_reliability_t reliability: (unstable) The reliability that should be used to transmit the data. */ typedef struct { z_congestion_control_t congestion_control; diff --git a/src/api/api.c b/src/api/api.c index 7883a46f6..829ce3211 100644 --- a/src/api/api.c +++ b/src/api/api.c @@ -214,202 +214,9 @@ z_result_t zp_config_insert(z_loaned_config_t *config, uint8_t key, const char * return _zp_config_insert(config, key, value); } -#if Z_FEATURE_ENCODING_VALUES == 1 -#define ENCODING_SCHEMA_SEPARATOR ';' - -const char *ENCODING_VALUES_ID_TO_STR[] = { - "zenoh/bytes", - "zenoh/int8", - "zenoh/int16", - "zenoh/int32", - "zenoh/int64", - "zenoh/int128", - "zenoh/uint8", - "zenoh/uint16", - "zenoh/uint32", - "zenoh/uint64", - "zenoh/uint128", - "zenoh/float32", - "zenoh/float64", - "zenoh/bool", - "zenoh/string", - "zenoh/error", - "application/octet-stream", - "text/plain", - "application/json", - "text/json", - "application/cdr", - "application/cbor", - "application/yaml", - "text/yaml", - "text/json5", - "application/python-serialized-object", - "application/protobuf", - "application/java-serialized-object", - "application/openmetrics-text", - "image/png", - "image/jpeg", - "image/gif", - "image/bmp", - "image/webp", - "application/xml", - "application/x-www-form-urlencoded", - "text/html", - "text/xml", - "text/css", - "text/javascript", - "text/markdown", - "text/csv", - "application/sql", - "application/coap-payload", - "application/json-patch+json", - "application/json-seq", - "application/jsonpath", - "application/jwt", - "application/mp4", - "application/soap+xml", - "application/yang", - "audio/aac", - "audio/flac", - "audio/mp4", - "audio/ogg", - "audio/vorbis", - "video/h261", - "video/h263", - "video/h264", - "video/h265", - "video/h266", - "video/mp4", - "video/ogg", - "video/raw", - "video/vp8", - "video/vp9", -}; - -static uint16_t _z_encoding_values_str_to_int(const char *schema, size_t len) { - for (size_t i = 0; i < _ZP_ARRAY_SIZE(ENCODING_VALUES_ID_TO_STR); i++) { - if (strncmp(schema, ENCODING_VALUES_ID_TO_STR[i], len) == 0) { - return (uint16_t)i; - } - } - return UINT16_MAX; -} - -static z_result_t _z_encoding_convert_from_substr(z_owned_encoding_t *encoding, const char *s, size_t len) { - size_t pos = 0; - for (; pos < len; ++pos) { - if (s[pos] == ENCODING_SCHEMA_SEPARATOR) break; - } - - // Check id_end value + corner cases - if ((pos != len) && (pos != 0)) { - uint16_t id = _z_encoding_values_str_to_int(s, pos); - // Check id - if (id != UINT16_MAX) { - const char *ptr = (pos + 1 == len) ? NULL : s + pos + 1; - return _z_encoding_make(&encoding->_val, id, ptr, len - pos - 1); - } - } - // By default store the string as schema - return _z_encoding_make(&encoding->_val, _Z_ENCODING_ID_DEFAULT, s, len); -} - -static z_result_t _z_encoding_convert_into_string(const z_loaned_encoding_t *encoding, z_owned_string_t *s) { - const char *prefix = NULL; - size_t prefix_len = 0; - // Convert id - if (encoding->id < _ZP_ARRAY_SIZE(ENCODING_VALUES_ID_TO_STR)) { - prefix = ENCODING_VALUES_ID_TO_STR[encoding->id]; - prefix_len = strlen(prefix); - } - bool has_schema = _z_string_len(&encoding->schema) > 0; - // Size include null terminator - size_t total_len = prefix_len + _z_string_len(&encoding->schema) + 1; - // Check for schema separator - if (has_schema) { - total_len += 1; - } - // Allocate string - char *value = (char *)z_malloc(sizeof(char) * total_len); - memset(value, 0, total_len); - if (value == NULL) { - return _Z_ERR_SYSTEM_OUT_OF_MEMORY; - } - // Copy prefix - char sep = ENCODING_SCHEMA_SEPARATOR; - (void)strncpy(value, prefix, prefix_len); - // Copy schema and separator - if (has_schema) { - (void)strncat(value, &sep, 1); - (void)strncat(value, _z_string_data(&encoding->schema), _z_string_len(&encoding->schema)); - } - // Fill container - s->_val = _z_string_from_str_custom_deleter(value, _z_delete_context_default()); - return _Z_RES_OK; -} - -#else -static z_result_t _z_encoding_convert_from_substr(z_owned_encoding_t *encoding, const char *s, size_t len) { - return _z_encoding_make(encoding->_val, _Z_ENCODING_ID_DEFAULT, s, len); -} - -static z_result_t _z_encoding_convert_into_string(const z_loaned_encoding_t *encoding, z_owned_string_t *s) { - _z_string_copy(s->_val, &encoding->schema); - return _Z_RES_OK; -} - -#endif - _Z_OWNED_FUNCTIONS_VALUE_IMPL(_z_encoding_t, encoding, _z_encoding_check, _z_encoding_null, _z_encoding_copy, _z_encoding_clear) -z_result_t z_encoding_from_str(z_owned_encoding_t *encoding, const char *s) { - // Init owned encoding - z_internal_encoding_null(encoding); - // Convert string to encoding - if (s != NULL) { - return _z_encoding_convert_from_substr(encoding, s, strlen(s)); - } - return _Z_RES_OK; -} - -z_result_t z_encoding_from_substr(z_owned_encoding_t *encoding, const char *s, size_t len) { - // Init owned encoding - z_internal_encoding_null(encoding); - // Convert string to encoding - if (s != NULL) { - return _z_encoding_convert_from_substr(encoding, s, len); - } - return _Z_RES_OK; -} -z_result_t z_encoding_set_schema_from_str(z_loaned_encoding_t *encoding, const char *schema) { - return z_encoding_set_schema_from_substr(encoding, schema, strlen(schema)); -} - -z_result_t z_encoding_set_schema_from_substr(z_loaned_encoding_t *encoding, const char *schema, size_t len) { - _z_string_clear(&encoding->schema); - if (schema == NULL && len > 0) { - return _Z_ERR_INVALID; - } - encoding->schema = _z_string_copy_from_substr(schema, len); - if (_z_string_len(&encoding->schema) != len) { - return _Z_ERR_SYSTEM_OUT_OF_MEMORY; - } - return _Z_RES_OK; -} - -z_result_t z_encoding_to_string(const z_loaned_encoding_t *encoding, z_owned_string_t *s) { - // Init owned string - z_internal_string_null(s); - // Convert encoding to string - _z_encoding_convert_into_string(encoding, s); - return _Z_RES_OK; -} - -bool z_encoding_equals(const z_loaned_encoding_t *left, const z_loaned_encoding_t *right) { - return left->id == right->id && _z_string_equals(&left->schema, &right->schema); -} - z_result_t z_slice_copy_from_buf(z_owned_slice_t *slice, const uint8_t *data, size_t len) { slice->_val = _z_slice_copy_from_buf(data, len); if (slice->_val.start == NULL) { diff --git a/src/api/encoding.c b/src/api/encoding.c new file mode 100644 index 000000000..b5cb4dc54 --- /dev/null +++ b/src/api/encoding.c @@ -0,0 +1,284 @@ +// +// Copyright (c) 2024 ZettaScale Technology +// +// This program and the accompanying materials are made available under the +// terms of the Eclipse Public License 2.0 which is available at +// http://www.eclipse.org/legal/epl-2.0, or the Apache License, Version 2.0 +// which is available at https://www.apache.org/licenses/LICENSE-2.0. +// +// SPDX-License-Identifier: EPL-2.0 OR Apache-2.0 +// +// Contributors: +// ZettaScale Zenoh Team, +// Błażej Sowa, + +#include +#include +#include +#include +#include + +#include "zenoh-pico.h" + +#if Z_FEATURE_ENCODING_VALUES == 1 +#define ENCODING_SCHEMA_SEPARATOR ';' + +#define ENCODING_CONSTANT_MACRO(_cname, _fname, _id) \ + const z_owned_encoding_t ZP_ENCODING_##_cname = { \ + ._val = { \ + .id = _id, \ + .schema = {._slice = {.start = NULL, .len = 0, ._delete_context = {.deleter = NULL, .context = NULL}}}, \ + }}; \ + inline const z_loaned_encoding_t *z_encoding_##_fname(void) { return &ZP_ENCODING_##_cname._val; } + +ENCODING_CONSTANT_MACRO(ZENOH_BYTES, zenoh_bytes, 0) +ENCODING_CONSTANT_MACRO(ZENOH_INT8, zenoh_int8, 1) +ENCODING_CONSTANT_MACRO(ZENOH_INT16, zenoh_int16, 2) +ENCODING_CONSTANT_MACRO(ZENOH_INT32, zenoh_int32, 3) +ENCODING_CONSTANT_MACRO(ZENOH_INT64, zenoh_int64, 4) +ENCODING_CONSTANT_MACRO(ZENOH_INT128, zenoh_int128, 5) +ENCODING_CONSTANT_MACRO(ZENOH_UINT8, zenoh_uint8, 6) +ENCODING_CONSTANT_MACRO(ZENOH_UINT16, zenoh_uint16, 7) +ENCODING_CONSTANT_MACRO(ZENOH_UINT32, zenoh_uint32, 8) +ENCODING_CONSTANT_MACRO(ZENOH_UINT64, zenoh_uint64, 9) +ENCODING_CONSTANT_MACRO(ZENOH_UINT128, zenoh_uint128, 10) +ENCODING_CONSTANT_MACRO(ZENOH_FLOAT32, zenoh_float32, 11) +ENCODING_CONSTANT_MACRO(ZENOH_FLOAT64, zenoh_float64, 12) +ENCODING_CONSTANT_MACRO(ZENOH_BOOL, zenoh_bool, 13) +ENCODING_CONSTANT_MACRO(ZENOH_STRING, zenoh_string, 14) +ENCODING_CONSTANT_MACRO(ZENOH_ERROR, zenoh_error, 15) +ENCODING_CONSTANT_MACRO(APPLICATION_OCTET_STREAM, application_octet_stream, 16) +ENCODING_CONSTANT_MACRO(TEXT_PLAIN, text_plain, 17) +ENCODING_CONSTANT_MACRO(APPLICATION_JSON, application_json, 18) +ENCODING_CONSTANT_MACRO(TEXT_JSON, text_json, 19) +ENCODING_CONSTANT_MACRO(APPLICATION_CDR, application_cdr, 20) +ENCODING_CONSTANT_MACRO(APPLICATION_CBOR, application_cbor, 21) +ENCODING_CONSTANT_MACRO(APPLICATION_YAML, application_yaml, 22) +ENCODING_CONSTANT_MACRO(TEXT_YAML, text_yaml, 23) +ENCODING_CONSTANT_MACRO(TEXT_JSON5, text_json5, 24) +ENCODING_CONSTANT_MACRO(APPLICATION_PYTHON_SERIALIZED_OBJECT, application_python_serialized_object, 25) +ENCODING_CONSTANT_MACRO(APPLICATION_PROTOBUF, application_protobuf, 26) +ENCODING_CONSTANT_MACRO(APPLICATION_JAVA_SERIALIZED_OBJECT, application_java_serialized_object, 27) +ENCODING_CONSTANT_MACRO(APPLICATION_OPENMETRICS_TEXT, application_openmetrics_text, 28) +ENCODING_CONSTANT_MACRO(IMAGE_PNG, image_png, 29) +ENCODING_CONSTANT_MACRO(IMAGE_JPEG, image_jpeg, 30) +ENCODING_CONSTANT_MACRO(IMAGE_GIF, image_gif, 31) +ENCODING_CONSTANT_MACRO(IMAGE_BMP, image_bmp, 32) +ENCODING_CONSTANT_MACRO(IMAGE_WEBP, image_webp, 33) +ENCODING_CONSTANT_MACRO(APPLICATION_XML, application_xml, 34) +ENCODING_CONSTANT_MACRO(APPLICATION_X_WWW_FORM_URLENCODED, application_x_www_form_urlencoded, 35) +ENCODING_CONSTANT_MACRO(TEXT_HTML, text_html, 36) +ENCODING_CONSTANT_MACRO(TEXT_XML, text_xml, 37) +ENCODING_CONSTANT_MACRO(TEXT_CSS, text_css, 38) +ENCODING_CONSTANT_MACRO(TEXT_JAVASCRIPT, text_javascript, 39) +ENCODING_CONSTANT_MACRO(TEXT_MARKDOWN, text_markdown, 40) +ENCODING_CONSTANT_MACRO(TEXT_CSV, text_csv, 41) +ENCODING_CONSTANT_MACRO(APPLICATION_SQL, application_sql, 42) +ENCODING_CONSTANT_MACRO(APPLICATION_COAP_PAYLOAD, application_coap_payload, 43) +ENCODING_CONSTANT_MACRO(APPLICATION_JSON_PATCH_JSON, application_json_patch_json, 44) +ENCODING_CONSTANT_MACRO(APPLICATION_JSON_SEQ, application_json_seq, 45) +ENCODING_CONSTANT_MACRO(APPLICATION_JSONPATH, application_jsonpath, 46) +ENCODING_CONSTANT_MACRO(APPLICATION_JWT, application_jwt, 47) +ENCODING_CONSTANT_MACRO(APPLICATION_MP4, application_mp4, 48) +ENCODING_CONSTANT_MACRO(APPLICATION_SOAP_XML, application_soap_xml, 49) +ENCODING_CONSTANT_MACRO(APPLICATION_YANG, application_yang, 50) +ENCODING_CONSTANT_MACRO(AUDIO_AAC, audio_aac, 51) +ENCODING_CONSTANT_MACRO(AUDIO_FLAC, audio_flac, 52) +ENCODING_CONSTANT_MACRO(AUDIO_MP4, audio_mp4, 53) +ENCODING_CONSTANT_MACRO(AUDIO_OGG, audio_ogg, 54) +ENCODING_CONSTANT_MACRO(AUDIO_VORBIS, audio_vorbis, 55) +ENCODING_CONSTANT_MACRO(VIDEO_H261, video_h261, 56) +ENCODING_CONSTANT_MACRO(VIDEO_H263, video_h263, 57) +ENCODING_CONSTANT_MACRO(VIDEO_H264, video_h264, 58) +ENCODING_CONSTANT_MACRO(VIDEO_H265, video_h265, 59) +ENCODING_CONSTANT_MACRO(VIDEO_H266, video_h266, 60) +ENCODING_CONSTANT_MACRO(VIDEO_MP4, video_mp4, 61) +ENCODING_CONSTANT_MACRO(VIDEO_OGG, video_ogg, 62) +ENCODING_CONSTANT_MACRO(VIDEO_RAW, video_raw, 63) +ENCODING_CONSTANT_MACRO(VIDEO_VP8, video_vp8, 64) +ENCODING_CONSTANT_MACRO(VIDEO_VP9, video_vp9, 65) + +const char *ENCODING_VALUES_ID_TO_STR[] = { + "zenoh/bytes", + "zenoh/int8", + "zenoh/int16", + "zenoh/int32", + "zenoh/int64", + "zenoh/int128", + "zenoh/uint8", + "zenoh/uint16", + "zenoh/uint32", + "zenoh/uint64", + "zenoh/uint128", + "zenoh/float32", + "zenoh/float64", + "zenoh/bool", + "zenoh/string", + "zenoh/error", + "application/octet-stream", + "text/plain", + "application/json", + "text/json", + "application/cdr", + "application/cbor", + "application/yaml", + "text/yaml", + "text/json5", + "application/python-serialized-object", + "application/protobuf", + "application/java-serialized-object", + "application/openmetrics-text", + "image/png", + "image/jpeg", + "image/gif", + "image/bmp", + "image/webp", + "application/xml", + "application/x-www-form-urlencoded", + "text/html", + "text/xml", + "text/css", + "text/javascript", + "text/markdown", + "text/csv", + "application/sql", + "application/coap-payload", + "application/json-patch+json", + "application/json-seq", + "application/jsonpath", + "application/jwt", + "application/mp4", + "application/soap+xml", + "application/yang", + "audio/aac", + "audio/flac", + "audio/mp4", + "audio/ogg", + "audio/vorbis", + "video/h261", + "video/h263", + "video/h264", + "video/h265", + "video/h266", + "video/mp4", + "video/ogg", + "video/raw", + "video/vp8", + "video/vp9", +}; + +static uint16_t _z_encoding_values_str_to_int(const char *schema, size_t len) { + for (size_t i = 0; i < _ZP_ARRAY_SIZE(ENCODING_VALUES_ID_TO_STR); i++) { + if (strncmp(schema, ENCODING_VALUES_ID_TO_STR[i], len) == 0) { + return (uint16_t)i; + } + } + return UINT16_MAX; +} + +static z_result_t _z_encoding_convert_from_substr(z_owned_encoding_t *encoding, const char *s, size_t len) { + size_t pos = 0; + for (; pos < len; ++pos) { + if (s[pos] == ENCODING_SCHEMA_SEPARATOR) break; + } + + // Check id_end value + corner cases + if ((pos != len) && (pos != 0)) { + uint16_t id = _z_encoding_values_str_to_int(s, pos); + // Check id + if (id != UINT16_MAX) { + const char *ptr = (pos + 1 == len) ? NULL : s + pos + 1; + return _z_encoding_make(&encoding->_val, id, ptr, len - pos - 1); + } + } + // By default store the string as schema + return _z_encoding_make(&encoding->_val, _Z_ENCODING_ID_DEFAULT, s, len); +} + +static z_result_t _z_encoding_convert_into_string(const z_loaned_encoding_t *encoding, z_owned_string_t *s) { + const char *prefix = NULL; + size_t prefix_len = 0; + // Convert id + if (encoding->id < _ZP_ARRAY_SIZE(ENCODING_VALUES_ID_TO_STR)) { + prefix = ENCODING_VALUES_ID_TO_STR[encoding->id]; + prefix_len = strlen(prefix); + } + _Bool has_schema = _z_string_len(&encoding->schema) > 0; + // Size include null terminator + size_t total_len = prefix_len + _z_string_len(&encoding->schema) + 1; + // Check for schema separator + if (has_schema) { + total_len += 1; + } + // Allocate string + char *value = (char *)z_malloc(sizeof(char) * total_len); + memset(value, 0, total_len); + if (value == NULL) { + return _Z_ERR_SYSTEM_OUT_OF_MEMORY; + } + // Copy prefix + char sep = ENCODING_SCHEMA_SEPARATOR; + (void)strncpy(value, prefix, prefix_len); + // Copy schema and separator + if (has_schema) { + (void)strncat(value, &sep, 1); + (void)strncat(value, _z_string_data(&encoding->schema), _z_string_len(&encoding->schema)); + } + // Fill container + s->_val = _z_string_from_str_custom_deleter(value, _z_delete_context_default()); + return _Z_RES_OK; +} + +#else +static z_result_t _z_encoding_convert_from_substr(z_owned_encoding_t *encoding, const char *s, size_t len) { + return _z_encoding_make(&encoding->_val, _Z_ENCODING_ID_DEFAULT, s, len); +} + +static z_result_t _z_encoding_convert_into_string(const z_loaned_encoding_t *encoding, z_owned_string_t *s) { + _z_string_copy(&s->_val, &encoding->schema); + return _Z_RES_OK; +} +#endif + +z_result_t z_encoding_from_str(z_owned_encoding_t *encoding, const char *s) { + // Init owned encoding + z_internal_encoding_null(encoding); + // Convert string to encoding + if (s != NULL) { + return _z_encoding_convert_from_substr(encoding, s, strlen(s)); + } + return _Z_RES_OK; +} + +z_result_t z_encoding_from_substr(z_owned_encoding_t *encoding, const char *s, size_t len) { + // Init owned encoding + z_internal_encoding_null(encoding); + // Convert string to encoding + if (s != NULL) { + return _z_encoding_convert_from_substr(encoding, s, len); + } + return _Z_RES_OK; +} +z_result_t z_encoding_set_schema_from_str(z_loaned_encoding_t *encoding, const char *schema) { + return z_encoding_set_schema_from_substr(encoding, schema, strlen(schema)); +} + +z_result_t z_encoding_set_schema_from_substr(z_loaned_encoding_t *encoding, const char *schema, size_t len) { + _z_string_clear(&encoding->schema); + if (schema == NULL && len > 0) { + return _Z_ERR_INVALID; + } + encoding->schema = _z_string_copy_from_substr(schema, len); + if (_z_string_len(&encoding->schema) != len) { + return _Z_ERR_SYSTEM_OUT_OF_MEMORY; + } + return _Z_RES_OK; +} + +z_result_t z_encoding_to_string(const z_loaned_encoding_t *encoding, z_owned_string_t *s) { + // Init owned string + z_internal_string_null(s); + // Convert encoding to string + _z_encoding_convert_into_string(encoding, s); + return _Z_RES_OK; +} diff --git a/src/system/unix/system.c b/src/system/unix/system.c index e05205117..2049fba30 100644 --- a/src/system/unix/system.c +++ b/src/system/unix/system.c @@ -160,7 +160,7 @@ z_result_t z_sleep_ms(size_t time) { return _Z_RES_OK; } -z_result_t z_sleep_s(size_t time) { _Z_CHECK_SYS_ERR(sleep((unsigned int)time)); } +z_result_t z_sleep_s(size_t time) { _Z_CHECK_SYS_ERR((int)sleep((unsigned int)time)); } /*------------------ Instant ------------------*/ z_clock_t z_clock_now(void) {