types.h

Go to the documentation of this file.

// Copyright 2014-2017 Open Source Robotics Foundation, Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef RMW__TYPES_H_
#define RMW__TYPES_H_

#ifdef __cplusplus
extern "C"
{
#endif

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

// map rcutils specific log levels to rmw speicfic type
#include <rcutils/logging.h>

#include "rmw/init.h"
#include "rmw/loaned_message_sequence.h"
#include "rmw/ret_types.h"
#include "rmw/serialized_message.h"
#include "rmw/visibility_control.h"

// 24 bytes is the most memory needed to represent the GID by any current
// implementation. It may need to be increased in the future.
#define RMW_GID_STORAGE_SIZE 24

typedef struct RMW_PUBLIC_TYPE rmw_node_t
{
  const char * implementation_identifier;
  void * data;
  const char * name;
  const char * namespace_;
  rmw_context_t * context;
} rmw_node_t;

typedef struct RMW_PUBLIC_TYPE rmw_publisher_options_t
{

  void * rmw_specific_publisher_payload;
} rmw_publisher_options_t;

typedef struct RMW_PUBLIC_TYPE rmw_publisher_t
{
  const char * implementation_identifier;
  void * data;
  const char * topic_name;

  rmw_publisher_options_t options;
  bool can_loan_messages;
} rmw_publisher_t;

typedef struct RMW_PUBLIC_TYPE rmw_subscription_options_t
{

  void * rmw_specific_subscription_payload;


  bool ignore_local_publications;
} rmw_subscription_options_t;

typedef struct RMW_PUBLIC_TYPE rmw_subscription_t
{
  const char * implementation_identifier;
  void * data;
  const char * topic_name;

  rmw_subscription_options_t options;
  bool can_loan_messages;
} rmw_subscription_t;

typedef struct RMW_PUBLIC_TYPE rmw_service_t
{
  const char * implementation_identifier;
  void * data;
  const char * service_name;
} rmw_service_t;

typedef struct RMW_PUBLIC_TYPE rmw_client_t
{
  const char * implementation_identifier;
  void * data;
  const char * service_name;
} rmw_client_t;

typedef struct RMW_PUBLIC_TYPE rmw_guard_condition_t
{
  const char * implementation_identifier;
  void * data;
  rmw_context_t * context;
} rmw_guard_condition_t;

typedef struct RMW_PUBLIC_TYPE rmw_publisher_allocation_t
{
  const char * implementation_identifier;
  void * data;
} rmw_publisher_allocation_t;

typedef struct RMW_PUBLIC_TYPE rmw_subscription_allocation_t
{
  const char * implementation_identifier;
  void * data;
} rmw_subscription_allocation_t;


typedef struct RMW_PUBLIC_TYPE rmw_subscriptions_t
{
  size_t subscriber_count;
  void ** subscribers;
} rmw_subscriptions_t;


typedef struct RMW_PUBLIC_TYPE rmw_services_t
{
  size_t service_count;
  void ** services;
} rmw_services_t;


typedef struct RMW_PUBLIC_TYPE rmw_clients_t
{
  size_t client_count;
  void ** clients;
} rmw_clients_t;

typedef struct RMW_PUBLIC_TYPE rmw_events_t
{
  size_t event_count;
  void ** events;
} rmw_events_t;


typedef struct RMW_PUBLIC_TYPE rmw_guard_conditions_t
{
  size_t guard_condition_count;
  void ** guard_conditions;
} rmw_guard_conditions_t;

typedef struct RMW_PUBLIC_TYPE rmw_wait_set_t
{
  const char * implementation_identifier;
  rmw_guard_conditions_t * guard_conditions;
  void * data;
} rmw_wait_set_t;

typedef struct RMW_PUBLIC_TYPE rmw_request_id_t
{
  int8_t writer_guid[16];
  int64_t sequence_number;
} rmw_request_id_t;

typedef struct RMW_PUBLIC_TYPE rmw_time_t
{
  uint64_t sec;
  uint64_t nsec;
} rmw_time_t;

enum RMW_PUBLIC_TYPE rmw_security_enforcement_policy_t
{
  RMW_SECURITY_ENFORCEMENT_PERMISSIVE,
  RMW_SECURITY_ENFORCEMENT_ENFORCE,
};

typedef struct RMW_PUBLIC_TYPE rmw_node_security_options_t
{
  enum rmw_security_enforcement_policy_t enforce_security;
  const char * security_root_path;
} rmw_node_security_options_t;

enum RMW_PUBLIC_TYPE rmw_qos_reliability_policy_t
{
  RMW_QOS_POLICY_RELIABILITY_SYSTEM_DEFAULT,
  RMW_QOS_POLICY_RELIABILITY_RELIABLE,
  RMW_QOS_POLICY_RELIABILITY_BEST_EFFORT,
  RMW_QOS_POLICY_RELIABILITY_UNKNOWN
};

enum RMW_PUBLIC_TYPE rmw_qos_history_policy_t
{
  RMW_QOS_POLICY_HISTORY_SYSTEM_DEFAULT,
  RMW_QOS_POLICY_HISTORY_KEEP_LAST,
  RMW_QOS_POLICY_HISTORY_KEEP_ALL,
  RMW_QOS_POLICY_HISTORY_UNKNOWN
};

enum RMW_PUBLIC_TYPE rmw_qos_durability_policy_t
{
  RMW_QOS_POLICY_DURABILITY_SYSTEM_DEFAULT,
  RMW_QOS_POLICY_DURABILITY_TRANSIENT_LOCAL,
  RMW_QOS_POLICY_DURABILITY_VOLATILE,
  RMW_QOS_POLICY_DURABILITY_UNKNOWN
};

enum RMW_PUBLIC_TYPE rmw_qos_liveliness_policy_t
{
  RMW_QOS_POLICY_LIVELINESS_SYSTEM_DEFAULT,
  RMW_QOS_POLICY_LIVELINESS_AUTOMATIC,
  RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_NODE,
  RMW_QOS_POLICY_LIVELINESS_MANUAL_BY_TOPIC,
  RMW_QOS_POLICY_LIVELINESS_UNKNOWN
};

#define RMW_QOS_DEADLINE_DEFAULT {0, 0}
#define RMW_QOS_LIFESPAN_DEFAULT {0, 0}
#define RMW_QOS_LIVELINESS_LEASE_DURATION_DEFAULT {0, 0}

typedef struct RMW_PUBLIC_TYPE rmw_qos_profile_t
{
  enum rmw_qos_history_policy_t history;
  size_t depth;
  enum rmw_qos_reliability_policy_t reliability;
  enum rmw_qos_durability_policy_t durability;
  struct rmw_time_t deadline;
  struct rmw_time_t lifespan;
  enum rmw_qos_liveliness_policy_t liveliness;
  struct rmw_time_t liveliness_lease_duration;


  bool avoid_ros_namespace_conventions;
} rmw_qos_profile_t;

typedef struct RMW_PUBLIC_TYPE rmw_gid_t
{
  const char * implementation_identifier;
  uint8_t data[RMW_GID_STORAGE_SIZE];
} rmw_gid_t;

typedef struct RMW_PUBLIC_TYPE rmw_message_info_t
{
  // const rmw_time_t received_timestamp;
  rmw_gid_t publisher_gid;
  bool from_intra_process;
} rmw_message_info_t;

typedef struct RMW_PUBLIC_TYPE rmw_message_info_sequence_t
{
  rmw_message_info_t * message_info_sequence;
  size_t size;
  size_t capacity;
} rmw_message_info_sequence_t;

enum {RMW_QOS_POLICY_DEPTH_SYSTEM_DEFAULT = 0};

typedef enum RMW_PUBLIC_TYPE
{
  RMW_LOG_SEVERITY_DEBUG = RCUTILS_LOG_SEVERITY_DEBUG,
  RMW_LOG_SEVERITY_INFO = RCUTILS_LOG_SEVERITY_INFO,
  RMW_LOG_SEVERITY_WARN = RCUTILS_LOG_SEVERITY_WARN,
  RMW_LOG_SEVERITY_ERROR = RCUTILS_LOG_SEVERITY_ERROR,
  RMW_LOG_SEVERITY_FATAL = RCUTILS_LOG_SEVERITY_FATAL
} rmw_log_severity_t;

typedef struct RMW_PUBLIC_TYPE rmw_liveliness_changed_status_t
{
  int32_t alive_count;
  int32_t not_alive_count;
  int32_t alive_count_change;
  int32_t not_alive_count_change;
} rmw_liveliness_changed_status_t;

typedef struct RMW_PUBLIC_TYPE rmw_requested_deadline_missed_status_t
{
  int32_t total_count;
  int32_t total_count_change;
} rmw_requested_deadline_missed_status_t;

typedef struct RMW_PUBLIC_TYPE rmw_liveliness_lost_status_t
{
  int32_t total_count;
  int32_t total_count_change;
} rmw_liveliness_lost_status_t;

typedef struct RMW_PUBLIC_TYPE rmw_offered_deadline_missed_status_t
{
  int32_t total_count;
  int32_t total_count_change;
} rmw_offered_deadline_missed_status_t;

#ifdef __cplusplus
}
#endif

#endif  // RMW__TYPES_H_