config.h

// Copyright 2020 The Pigweed Authors
//
// 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
//
//     https://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.
 
// Configuration macros for the pw_rpc module.
#pragma once
 
#include <cstddef>
#include <type_traits>
 
#if defined(PW_RPC_CLIENT_STREAM_END_CALLBACK) && \
    PW_RPC_CLIENT_STREAM_END_CALLBACK
#pragma message(                                                \
    "Warning PW_RPC_CLIENT_STREAM_END_CALLBACK is deprecated! " \
    "Use PW_RPC_COMPLETION_REQUEST_CALLBACK instead.")
#define PW_RPC_COMPLETION_REQUEST_CALLBACK 1
#endif
 
#undef PW_RPC_CLIENT_STREAM_END_CALLBACK
 
 
#ifndef PW_RPC_COMPLETION_REQUEST_CALLBACK
#define PW_RPC_COMPLETION_REQUEST_CALLBACK 0
#endif  // PW_RPC_COMPLETION_REQUEST_CALLBACK
 
#ifndef PW_RPC_METHOD_STORES_TYPE
#define PW_RPC_METHOD_STORES_TYPE 0
#endif  // PW_RPC_METHOD_STORES_TYPE
 
#ifndef PW_RPC_NANOPB_STRUCT_MIN_BUFFER_SIZE
#define PW_RPC_NANOPB_STRUCT_MIN_BUFFER_SIZE 64
#endif  // PW_RPC_NANOPB_STRUCT_MIN_BUFFER_SIZE
 
#ifndef PW_RPC_USE_GLOBAL_MUTEX
#define PW_RPC_USE_GLOBAL_MUTEX 1
#endif  // PW_RPC_USE_GLOBAL_MUTEX
 
#ifndef PW_RPC_YIELD_MODE
#if PW_RPC_USE_GLOBAL_MUTEX == 0
#define PW_RPC_YIELD_MODE PW_RPC_YIELD_MODE_BUSY_LOOP
#else
#define PW_RPC_YIELD_MODE PW_RPC_YIELD_MODE_SLEEP
#endif  // PW_RPC_USE_GLOBAL_MUTEX == 0
#endif  // PW_RPC_YIELD_MODE
 
// LINT.IfChange
#define PW_RPC_YIELD_MODE_BUSY_LOOP 100
#define PW_RPC_YIELD_MODE_SLEEP 101
#define PW_RPC_YIELD_MODE_YIELD 102
// LINT.ThenChange(//pw_rpc/BUILD.bazel)
 
#ifndef PW_RPC_YIELD_SLEEP_DURATION
 
// When building for a desktop operating system, use a 1ms sleep by default.
// 1-tick duration sleeps can result in spurious timeouts.
#if defined(_WIN32) || defined(__APPLE__) || \
    defined(__linux__) && !defined(__ZEPHYR__)
#define PW_RPC_YIELD_SLEEP_DURATION std::chrono::milliseconds(1)
#else
#define PW_RPC_YIELD_SLEEP_DURATION pw::chrono::SystemClock::duration(1)
#endif  // defined(_WIN32) || defined(__APPLE__) || defined(__linux__)
        // && !defined(__ZEPHYR__)
 
#endif  // PW_RPC_YIELD_SLEEP_DURATION
 
// PW_RPC_YIELD_SLEEP_DURATION is not needed for non-sleep yield modes.
#if PW_RPC_YIELD_MODE != PW_RPC_YIELD_MODE_SLEEP
#undef PW_RPC_YIELD_SLEEP_DURATION
#endif  // PW_RPC_YIELD_MODE != PW_RPC_YIELD_MODE_SLEEP
 
#ifndef PW_RPC_CALLBACK_TIMEOUT_TICKS
#define PW_RPC_CALLBACK_TIMEOUT_TICKS 10000
#endif  // PW_RPC_CALLBACK_TIMEOUT_TICKS
 
#ifndef PW_RPC_DYNAMIC_ALLOCATION
#define PW_RPC_DYNAMIC_ALLOCATION 0
#endif  // PW_RPC_DYNAMIC_ALLOCATION
 
#ifndef PW_RPC_ALLOW_INVOCATIONS_ON_STACK
#define PW_RPC_ALLOW_INVOCATIONS_ON_STACK 1
#endif  // PW_RPC_ALLOW_INVOCATIONS_ON_STACK
 
static_assert(PW_RPC_ALLOW_INVOCATIONS_ON_STACK || PW_RPC_DYNAMIC_ALLOCATION,
              "If PW_RPC_ALLOW_INVOCATIONS_ON_STACK is 0, "
              "PW_RPC_DYNAMIC_ALLOCATION must be 1 to allow RPC calls.");
 
#if defined(PW_RPC_DYNAMIC_CONTAINER) || \
    defined(PW_RPC_DYNAMIC_CONTAINER_INCLUDE)
static_assert(
    PW_RPC_DYNAMIC_ALLOCATION == 1,
    "PW_RPC_DYNAMIC_ALLOCATION is disabled, so PW_RPC_DYNAMIC_CONTAINER and "
    "PW_RPC_DYNAMIC_CONTAINER_INCLUDE have no effect and should not be set.");
#endif  // PW_RPC_DYNAMIC_CONTAINER || PW_RPC_DYNAMIC_CONTAINER_INCLUDE
 
#ifndef PW_RPC_DYNAMIC_CONTAINER
#define PW_RPC_DYNAMIC_CONTAINER(type) std::vector<type>
#endif  // PW_RPC_DYNAMIC_CONTAINER
 
#ifndef PW_RPC_DYNAMIC_CONTAINER_INCLUDE
#define PW_RPC_DYNAMIC_CONTAINER_INCLUDE <vector>
#endif  // PW_RPC_DYNAMIC_CONTAINER_INCLUDE
 
#ifndef PW_RPC_MAKE_UNIQUE_PTR
#define PW_RPC_MAKE_UNIQUE_PTR(type, ...) \
  std::unique_ptr<type>(new type(__VA_ARGS__))
#endif  // PW_RPC_DYNAMIC_CONTAINER
 
#ifndef PW_RPC_MAKE_UNIQUE_PTR_INCLUDE
#define PW_RPC_MAKE_UNIQUE_PTR_INCLUDE <memory>
#endif  // PW_RPC_MAKE_UNIQUE_PTR_INCLUDE
 
#ifndef PW_RPC_ENCODING_BUFFER_SIZE_BYTES
#define PW_RPC_ENCODING_BUFFER_SIZE_BYTES 512
#endif  // PW_RPC_ENCODING_BUFFER_SIZE_BYTES
 
#ifndef PW_RPC_PWPB_SCRATCH_BUFFER_SIZE_BYTES
#define PW_RPC_PWPB_SCRATCH_BUFFER_SIZE_BYTES 64
#endif  // PW_RPC_PWPB_SCRATCH_BUFFER_SIZE_BYTES
 
#ifndef PW_RPC_CONFIG_LOG_LEVEL
#define PW_RPC_CONFIG_LOG_LEVEL PW_LOG_LEVEL_INFO
#endif  // PW_RPC_CONFIG_LOG_LEVEL
 
#ifndef PW_RPC_CONFIG_LOG_MODULE_NAME
#define PW_RPC_CONFIG_LOG_MODULE_NAME "PW_RPC"
#endif  // PW_RPC_CONFIG_LOG_MODULE_NAME
 
namespace pw::rpc::cfg {
 
template <typename...>
constexpr std::bool_constant<PW_RPC_COMPLETION_REQUEST_CALLBACK>
    kClientStreamEndCallbackEnabled;
 
template <typename...>
constexpr std::bool_constant<PW_RPC_METHOD_STORES_TYPE> kMethodStoresType;
 
template <typename...>
constexpr std::bool_constant<PW_RPC_DYNAMIC_ALLOCATION>
    kDynamicAllocationEnabled;
 
inline constexpr size_t kNanopbStructMinBufferSize =
    PW_RPC_NANOPB_STRUCT_MIN_BUFFER_SIZE;
 
inline constexpr size_t kEncodingBufferSizeBytes =
    PW_RPC_ENCODING_BUFFER_SIZE_BYTES;
 
inline constexpr size_t kPwpbScratchBufferSizeBytes =
    PW_RPC_PWPB_SCRATCH_BUFFER_SIZE_BYTES;
 
#undef PW_RPC_NANOPB_STRUCT_MIN_BUFFER_SIZE
#undef PW_RPC_ENCODING_BUFFER_SIZE_BYTES
#undef PW_RPC_PWPB_SCRATCH_BUFFER_SIZE_BYTES
 
}  // namespace pw::rpc::cfg
 
#ifndef PW_RPC_NANOPB_STRUCT_BUFFER_STACK_ALLOCATE
#define PW_RPC_NANOPB_STRUCT_BUFFER_STACK_ALLOCATE 1
#endif  // PW_RPC_NANOPB_STRUCT_BUFFER_STACK_ALLOCATE
 
#if PW_RPC_NANOPB_STRUCT_BUFFER_STACK_ALLOCATE
#define _PW_RPC_NANOPB_STRUCT_STORAGE_CLASS
#else
#define _PW_RPC_NANOPB_STRUCT_STORAGE_CLASS static
#endif  // PW_RPC_NANOPB_STRUCT_BUFFER_STACK_ALLOCATE
 
#undef PW_RPC_NANOPB_STRUCT_BUFFER_STACK_ALLOCATE