.. _program_listing_file_include_rcl_wait.h:

Program Listing for File wait.h
===============================

|exhale_lsh| :ref:`Return to documentation for file <file_include_rcl_wait.h>` (``include/rcl/wait.h``)

.. |exhale_lsh| unicode:: U+021B0 .. UPWARDS ARROW WITH TIP LEFTWARDS

.. code-block:: cpp

   // Copyright 2015 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 RCL__WAIT_H_
   #define RCL__WAIT_H_
   
   #ifdef __cplusplus
   extern "C"
   {
   #endif
   
   #include <stdbool.h>
   #include <stddef.h>
   
   #include "rcl/client.h"
   #include "rcl/guard_condition.h"
   #include "rcl/macros.h"
   #include "rcl/service.h"
   #include "rcl/subscription.h"
   #include "rcl/timer.h"
   #include "rcl/event.h"
   #include "rcl/types.h"
   #include "rcl/visibility_control.h"
   
   typedef struct rcl_wait_set_impl_s rcl_wait_set_impl_t;
   
   typedef struct rcl_wait_set_s
   {
     const rcl_subscription_t ** subscriptions;
     size_t size_of_subscriptions;
     const rcl_guard_condition_t ** guard_conditions;
     size_t size_of_guard_conditions;
     const rcl_timer_t ** timers;
     size_t size_of_timers;
     const rcl_client_t ** clients;
     size_t size_of_clients;
     const rcl_service_t ** services;
     size_t size_of_services;
     const rcl_event_t ** events;
     size_t size_of_events;
     rcl_wait_set_impl_t * impl;
   } rcl_wait_set_t;
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_wait_set_t
   rcl_get_zero_initialized_wait_set(void);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait_set_init(
     rcl_wait_set_t * wait_set,
     size_t number_of_subscriptions,
     size_t number_of_guard_conditions,
     size_t number_of_timers,
     size_t number_of_clients,
     size_t number_of_services,
     size_t number_of_events,
     rcl_context_t * context,
     rcl_allocator_t allocator);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait_set_fini(rcl_wait_set_t * wait_set);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait_set_get_allocator(const rcl_wait_set_t * wait_set, rcl_allocator_t * allocator);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait_set_add_subscription(
     rcl_wait_set_t * wait_set,
     const rcl_subscription_t * subscription,
     size_t * index);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait_set_clear(rcl_wait_set_t * wait_set);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait_set_resize(
     rcl_wait_set_t * wait_set,
     size_t subscriptions_size,
     size_t guard_conditions_size,
     size_t timers_size,
     size_t clients_size,
     size_t services_size,
     size_t events_size);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait_set_add_guard_condition(
     rcl_wait_set_t * wait_set,
     const rcl_guard_condition_t * guard_condition,
     size_t * index);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait_set_add_timer(
     rcl_wait_set_t * wait_set,
     const rcl_timer_t * timer,
     size_t * index);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait_set_add_client(
     rcl_wait_set_t * wait_set,
     const rcl_client_t * client,
     size_t * index);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait_set_add_service(
     rcl_wait_set_t * wait_set,
     const rcl_service_t * service,
     size_t * index);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait_set_add_event(
     rcl_wait_set_t * wait_set,
     const rcl_event_t * event,
     size_t * index);
   
   
   RCL_PUBLIC
   RCL_WARN_UNUSED
   rcl_ret_t
   rcl_wait(rcl_wait_set_t * wait_set, int64_t timeout);
   
   
   RCL_PUBLIC
   bool
   rcl_wait_set_is_valid(const rcl_wait_set_t * wait_set);
   
   #ifdef __cplusplus
   }
   #endif
   
   #endif  // RCL__WAIT_H_