clearly specify where key expression might be declared and where it is not

Author: DenisBiryukov91

include/zenoh-pico/api/liveliness.h

@@ -27,7 +27,6 @@ extern "C" {
 
 typedef struct {
     uint32_t _id;
-    _z_keyexpr_t _key;
     _z_session_weak_t _zn;
 } _z_liveliness_token_t;
 

include/zenoh-pico/api/types.h

@@ -95,8 +95,8 @@ _Z_VIEW_TYPE(_z_string_t, string)
 /**
  * Represents a key expression in Zenoh.
  */
-_Z_OWNED_TYPE_VALUE(_z_keyexpr_t, keyexpr)
-_Z_VIEW_TYPE(_z_keyexpr_t, keyexpr)
+_Z_OWNED_TYPE_VALUE(_z_declared_keyexpr_t, keyexpr)
+_Z_VIEW_TYPE(_z_declared_keyexpr_t, keyexpr)
 
 /**
  * Represents a Zenoh configuration, used to configure Zenoh sessions upon opening.

include/zenoh-pico/net/filtering.h

@@ -80,8 +80,9 @@ typedef struct _z_write_filter_t {
     _z_write_filter_ctx_rc_t ctx;
 } _z_write_filter_t;
 
-z_result_t _z_write_filter_create(const _z_session_rc_t *zn, _z_write_filter_t *filter, const _z_keyexpr_t *keyexpr,
-                                  uint8_t interest_flag, bool complete, z_locality_t locality);
+z_result_t _z_write_filter_create(const _z_session_rc_t *zn, _z_write_filter_t *filter,
+                                  const _z_declared_keyexpr_t *keyexpr, uint8_t interest_flag, bool complete,
+                                  z_locality_t locality);
 z_result_t _z_write_filter_clear(_z_write_filter_t *filter);
 void _z_write_filter_notify_subscriber(struct _z_session_t *session, const _z_keyexpr_t *key,
                                        z_locality_t allowed_origin, bool add);

include/zenoh-pico/net/liveliness.h

@@ -26,7 +26,7 @@ extern "C" {
 #if Z_FEATURE_LIVELINESS == 1
 
 z_result_t _z_declare_liveliness_token(const _z_session_rc_t *zn, _z_liveliness_token_t *ret_token,
-                                       const _z_keyexpr_t *keyexpr);
+                                       const _z_declared_keyexpr_t *keyexpr);
 z_result_t _z_undeclare_liveliness_token(_z_liveliness_token_t *token);
 
 #if Z_FEATURE_SUBSCRIPTION == 1
@@ -45,7 +45,7 @@ z_result_t _z_undeclare_liveliness_token(_z_liveliness_token_t *token);
  *     0 in case of success, negative error code otherwise.
  */
 z_result_t _z_declare_liveliness_subscriber(_z_subscriber_t *subscriber, const _z_session_rc_t *zn,
-                                            const _z_keyexpr_t *keyexpr, _z_closure_sample_callback_t callback,
+                                            const _z_declared_keyexpr_t *keyexpr, _z_closure_sample_callback_t callback,
                                             _z_drop_handler_t dropper, bool history, void *arg);
 
 /**
@@ -73,7 +73,7 @@ z_result_t _z_undeclare_liveliness_subscriber(_z_subscriber_t *sub);
  *     timeout_ms: The timeout value of this query.
  *     opt_cancellation_token: Optional cancellation token, can be NULL.
  */
-z_result_t _z_liveliness_query(const _z_session_rc_t *session, const _z_keyexpr_t *keyexpr,
+z_result_t _z_liveliness_query(const _z_session_rc_t *session, const _z_declared_keyexpr_t *keyexpr,
                                _z_closure_reply_callback_t callback, _z_drop_handler_t dropper, void *arg,
                                uint64_t timeout_ms, _z_cancellation_token_rc_t *opt_cancellation_token);
 #endif  // Z_FEATURE_QUERY == 1

include/zenoh-pico/net/primitives.h

@@ -108,10 +108,10 @@ _z_keyexpr_t _z_update_keyexpr_to_declared(_z_session_t *zs, _z_keyexpr_t keyexp
  * Returns:
  *    0 in case of success, negative error code otherwise.
  */
-z_result_t _z_declare_publisher(_z_publisher_t *publisher, const _z_session_rc_t *zn, const _z_keyexpr_t *keyexpr,
-                                _z_encoding_t *encoding, z_congestion_control_t congestion_control,
-                                z_priority_t priority, bool is_express, z_reliability_t reliability,
-                                z_locality_t allowed_destination);
+z_result_t _z_declare_publisher(_z_publisher_t *publisher, const _z_session_rc_t *zn,
+                                const _z_declared_keyexpr_t *keyexpr, _z_encoding_t *encoding,
+                                z_congestion_control_t congestion_control, z_priority_t priority, bool is_express,
+                                z_reliability_t reliability, z_locality_t allowed_destination);
 
 /**
  * Undeclare a :c:type:`_z_publisher_t`.
@@ -146,9 +146,9 @@ z_result_t _z_undeclare_publisher(_z_publisher_t *pub);
  * Returns:
  *     ``0`` in case of success, ``-1`` in case of failure.
  */
-z_result_t _z_write(_z_session_t *zn, const _z_keyexpr_t *keyexpr, _z_bytes_t *payload, _z_encoding_t *encoding,
-                    const z_sample_kind_t kind, const z_congestion_control_t cong_ctrl, z_priority_t priority,
-                    bool is_express, const _z_timestamp_t *timestamp, _z_bytes_t *attachment,
+z_result_t _z_write(_z_session_t *zn, const _z_declared_keyexpr_t *keyexpr, _z_bytes_t *payload,
+                    _z_encoding_t *encoding, const z_sample_kind_t kind, const z_congestion_control_t cong_ctrl,
+                    z_priority_t priority, bool is_express, const _z_timestamp_t *timestamp, _z_bytes_t *attachment,
                     z_reliability_t reliability, const _z_source_info_t *source_info, z_locality_t allowed_destination);
 #endif
 
@@ -166,9 +166,9 @@ z_result_t _z_write(_z_session_t *zn, const _z_keyexpr_t *keyexpr, _z_bytes_t *p
  * Returns:
  *    0 in case of success, negative error code otherwise.
  */
-z_result_t _z_declare_subscriber(_z_subscriber_t *subscriber, const _z_session_rc_t *zn, const _z_keyexpr_t *keyexpr,
-                                 _z_closure_sample_callback_t callback, _z_drop_handler_t dropper, void *arg,
-                                 z_locality_t allowed_origin);
+z_result_t _z_declare_subscriber(_z_subscriber_t *subscriber, const _z_session_rc_t *zn,
+                                 const _z_declared_keyexpr_t *keyexpr, _z_closure_sample_callback_t callback,
+                                 _z_drop_handler_t dropper, void *arg, z_locality_t allowed_origin);
 
 /**
  * Undeclare a :c:type:`_z_subscriber_t`.
@@ -197,9 +197,10 @@ z_result_t _z_undeclare_subscriber(_z_subscriber_t *sub);
  * Returns:
  *    0 in case of success, negative error code otherwise.
  */
-z_result_t _z_declare_queryable(_z_queryable_t *queryable, const _z_session_rc_t *zn, const _z_keyexpr_t *keyexpr,
-                                bool complete, _z_closure_query_callback_t callback, _z_drop_handler_t dropper,
-                                void *arg, z_locality_t allowed_origin);
+z_result_t _z_declare_queryable(_z_queryable_t *queryable, const _z_session_rc_t *zn,
+                                const _z_declared_keyexpr_t *keyexpr, bool complete,
+                                _z_closure_query_callback_t callback, _z_drop_handler_t dropper, void *arg,
+                                z_locality_t allowed_origin);
 
 /**
  * Undeclare a :c:type:`_z_queryable_t`.
@@ -232,7 +233,7 @@ z_result_t _z_undeclare_queryable(_z_queryable_t *qle);
  *     timestamp: The timestamp of this reply. The API level timestamp (e.g. of the data when it was created).
  *     source_info: The message source info.
  */
-z_result_t _z_send_reply(const _z_query_t *query, const _z_session_rc_t *zsrc, const _z_keyexpr_t *keyexpr,
+z_result_t _z_send_reply(const _z_query_t *query, const _z_session_rc_t *zsrc, const _z_declared_keyexpr_t *keyexpr,
                          _z_bytes_t *payload, _z_encoding_t *encoding, const z_sample_kind_t kind,
                          const z_congestion_control_t cong_ctrl, z_priority_t priority, bool is_express,
                          const _z_timestamp_t *timestamp, _z_bytes_t *attachment, _z_source_info_t *source_info);
@@ -270,7 +271,7 @@ z_result_t _z_send_reply_err(const _z_query_t *query, const _z_session_rc_t *zsr
  * Returns:
  *    0 in case of success, negative error code otherwise.
  */
-z_result_t _z_declare_querier(_z_querier_t *querier, const _z_session_rc_t *zn, const _z_keyexpr_t *keyexpr,
+z_result_t _z_declare_querier(_z_querier_t *querier, const _z_session_rc_t *zn, const _z_declared_keyexpr_t *keyexpr,
                               z_consolidation_mode_t consolidation_mode, z_congestion_control_t congestion_control,
                               z_query_target_t target, z_priority_t priority, bool is_express, uint64_t timeout_ms,
                               _z_encoding_t *encoding, z_reliability_t reliability, z_locality_t allowed_destination);
@@ -308,7 +309,7 @@ z_result_t _z_undeclare_querier(_z_querier_t *querier);
  *     opt_cancellation_token: Optional cancellation token to cancel the query, can be null.
  *
  */
-z_result_t _z_query(const _z_session_rc_t *session, const _z_keyexpr_t *keyexpr, const char *parameters,
+z_result_t _z_query(const _z_session_rc_t *session, const _z_declared_keyexpr_t *keyexpr, const char *parameters,
                     size_t parameters_len, z_query_target_t target, z_consolidation_mode_t consolidation,
                     _z_bytes_t *payload, _z_encoding_t *encoding, _z_closure_reply_callback_t callback,
                     _z_drop_handler_t dropper, void *arg, uint64_t timeout_ms, _z_bytes_t *attachment, _z_n_qos_t qos,
@@ -317,8 +318,8 @@ z_result_t _z_query(const _z_session_rc_t *session, const _z_keyexpr_t *keyexpr,
 #endif
 
 #if Z_FEATURE_INTEREST == 1
-uint32_t _z_add_interest(_z_session_t *zn, const _z_keyexpr_t *keyexpr, _z_interest_handler_t callback, uint8_t flags,
-                         _z_void_rc_t *arg);
+uint32_t _z_add_interest(_z_session_t *zn, const _z_declared_keyexpr_t *keyexpr, _z_interest_handler_t callback,
+                         uint8_t flags, _z_void_rc_t *arg);
 z_result_t _z_remove_interest(_z_session_t *zn, uint32_t interest_id);
 #endif
 

include/zenoh-pico/net/publish.h

@@ -28,7 +28,7 @@ extern "C" {
  * Return type when declaring a publisher.
  */
 typedef struct _z_publisher_t {
-    _z_keyexpr_t _key;
+    _z_declared_keyexpr_t _key;
     _z_zint_t _id;
     _z_session_weak_t _zn;
     _z_encoding_t _encoding;

include/zenoh-pico/net/query.h

@@ -31,7 +31,7 @@ extern "C" {
  * The query to be answered by a queryable.
  */
 typedef struct _z_query_t {
-    _z_keyexpr_t _key;
+    _z_declared_keyexpr_t _key;
     _z_value_t _value;
     uint32_t _request_id;
     _z_session_weak_t _zn;
@@ -45,8 +45,8 @@ typedef struct _z_query_t {
 // Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
 static inline _z_query_t _z_query_null(void) { return (_z_query_t){0}; }
 static inline bool _z_query_check(const _z_query_t *query) {
-    return _z_keyexpr_check(&query->_key) || _z_value_check(&query->_value) || _z_bytes_check(&query->_attachment) ||
-           _z_string_check(&query->_parameters);
+    return _z_declared_keyexpr_check(&query->_key) || _z_value_check(&query->_value) ||
+           _z_bytes_check(&query->_attachment) || _z_string_check(&query->_parameters);
 }
 z_result_t _z_query_send_reply_final(_z_query_t *q);
 z_result_t _z_session_send_reply_final(_z_session_t *session, uint32_t query_id, bool is_local);
@@ -59,7 +59,7 @@ _Z_REFCOUNT_DEFINE(_z_query, _z_query)
  * Return type when declaring a querier.
  */
 typedef struct _z_querier_t {
-    _z_keyexpr_t _key;
+    _z_declared_keyexpr_t _key;
     _z_zint_t _id;
     _z_session_weak_t _zn;
     _z_encoding_t _encoding;
@@ -96,7 +96,7 @@ static inline z_result_t _z_query_move_data(_z_query_t *dst, _z_value_t *value,
                                             _z_slice_t *parameters, const _z_session_weak_t *zn, uint32_t request_id,
                                             _z_bytes_t *attachment, bool anyke, const _z_source_info_t *source_info) {
     *dst = _z_query_null();
-    _Z_CLEAN_RETURN_IF_ERR(_z_keyexpr_move(&dst->_key, key), _z_query_clear(dst));
+    _Z_CLEAN_RETURN_IF_ERR(_z_keyexpr_move(&dst->_key._inner, key), _z_query_clear(dst));
     _Z_CLEAN_RETURN_IF_ERR(_z_value_move(&dst->_value, value), _z_query_clear(dst));
     _Z_CLEAN_RETURN_IF_ERR(_z_bytes_move(&dst->_attachment, attachment), _z_query_clear(dst));
     _Z_CLEAN_RETURN_IF_ERR(_z_slice_move(&dst->_parameters._slice, parameters), _z_query_clear(dst));

include/zenoh-pico/net/sample.h

@@ -36,7 +36,7 @@ extern "C" {
  *   _z_source_info_t source_info: The source info for this data sample (unstable).
  */
 typedef struct _z_sample_t {
-    _z_keyexpr_t keyexpr;
+    _z_declared_keyexpr_t keyexpr;
     _z_bytes_t payload;
     _z_timestamp_t timestamp;
     _z_encoding_t encoding;
@@ -51,7 +51,7 @@ void _z_sample_clear(_z_sample_t *sample);
 // Warning: None of the sub-types require a non-0 initialization. Add a init function if it changes.
 static inline _z_sample_t _z_sample_null(void) { return (_z_sample_t){0}; }
 static inline bool _z_sample_check(const _z_sample_t *sample) {
-    return _z_keyexpr_check(&sample->keyexpr) || _z_encoding_check(&sample->encoding) ||
+    return _z_declared_keyexpr_check(&sample->keyexpr) || _z_encoding_check(&sample->encoding) ||
            _z_bytes_check(&sample->payload) || _z_bytes_check(&sample->attachment);
 }
 static inline size_t _z_sample_size(const _z_sample_t *s) {
@@ -62,7 +62,7 @@ static inline size_t _z_sample_size(const _z_sample_t *s) {
 void _z_sample_steal_data(_z_sample_t *dst, _z_keyexpr_t *key, _z_bytes_t *payload, const _z_timestamp_t *timestamp,
                           _z_encoding_t *encoding, z_sample_kind_t kind, _z_qos_t qos, _z_bytes_t *attachment,
                           z_reliability_t reliability, _z_source_info_t *source_info);
-z_result_t _z_sample_copy_data(_z_sample_t *dst, const _z_keyexpr_t *key, const _z_bytes_t *payload,
+z_result_t _z_sample_copy_data(_z_sample_t *dst, const _z_declared_keyexpr_t *key, const _z_bytes_t *payload,
                                const _z_timestamp_t *timestamp, const _z_encoding_t *encoding, z_sample_kind_t kind,
                                _z_qos_t qos, const _z_bytes_t *attachment, z_reliability_t reliability,
                                const _z_source_info_t *source_info);

include/zenoh-pico/net/session.h

@@ -84,7 +84,7 @@ typedef struct _z_session_t {
 #endif
 
 #if Z_FEATURE_LIVELINESS == 1
-    _z_keyexpr_intmap_t _local_tokens;
+    _z_declared_keyexpr_intmap_t _local_tokens;
     _z_keyexpr_intmap_t _remote_tokens;
 #if Z_FEATURE_QUERY == 1
     uint32_t _liveliness_query_id;

include/zenoh-pico/protocol/core.h

@@ -174,11 +174,6 @@ static inline _z_wireexpr_t _z_wireexpr_null(void) {
     _z_wireexpr_t expr = {0};
     return expr;
 }
-static inline _z_wireexpr_t _z_wireexpr_alias_string(const _z_string_t *src) {
-    _z_wireexpr_t dst = _z_wireexpr_null();
-    dst._suffix = _z_string_alias(*src);
-    return dst;
-}
 static inline _z_wireexpr_t _z_wireexpr_steal(_z_wireexpr_t *expr) {
     _z_wireexpr_t expr2 = *expr;
     *expr = _z_wireexpr_null();