callback_context.hpp

Go to the documentation of this file.

// Copyright (c) 2024 Contributors to the Eclipse Foundation
//
// See the NOTICE file(s) distributed with this work for additional
// information regarding copyright ownership.
//
// This program and the accompanying materials are made available under the
// terms of the Apache Software License 2.0 which is available at
// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
// which is available at https://opensource.org/licenses/MIT.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
 
#ifndef IOX2_INTERNAL_CALLBACK_CONTEXT_HPP
#define IOX2_INTERNAL_CALLBACK_CONTEXT_HPP
 
#include "iox2/bb/optional.hpp"
#include "iox2/bb/static_function.hpp"
#include "iox2/internal/iceoryx2.hpp"
#include "iox2/node_details.hpp"
#include "iox2/node_name.hpp"
#include "iox2/node_state.hpp"
#include "iox2/service_type.hpp"
#include "iox2/unique_node_id.hpp"
 
namespace iox2 {
using OverridePreallocationCallback = iox2::bb::StaticFunction<size_t(size_t)>;
 
namespace internal {
template <typename T>
class CallbackContext {
  public:
    explicit CallbackContext(const T& ptr)
        : m_ptr { &ptr } {
    }
 
    auto value() const -> const T& {
        return *m_ptr;
    }
 
  private:
    const T* m_ptr;
};
 
template <typename T>
inline auto ctx(const T& ptr) -> CallbackContext<T> {
    return CallbackContext<T>(ptr);
}
 
template <typename T>
inline auto ctx_cast(void* ptr) -> CallbackContext<T>* {
    return static_cast<CallbackContext<T>*>(ptr);
}
 
inline auto override_callback(size_t value, iox2_callback_context ctx) -> size_t {
    // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) must be raw pointer because of C interface
    auto* context = ctx_cast<OverridePreallocationCallback>(ctx);
    auto ret_val = context->value()(value);
    // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) must be raw pointer because of C interface
    delete &context->value();
    // NOLINTNEXTLINE(cppcoreguidelines-owning-memory) must be raw pointer because of C interface
    delete context;
    return ret_val;
}
 
template <typename T, typename ViewType>
inline auto list_ports_callback(void* context, const T port_details_view) -> iox2_callback_progression_e {
    auto* callback = internal::ctx_cast<iox2::bb::StaticFunction<CallbackProgression(ViewType)>>(context);
    return iox2::bb::into<iox2_callback_progression_e>(callback->value()(ViewType(port_details_view)));
}
 
template <ServiceType T>
// NOLINTBEGIN(readability-function-size)
inline auto list_callback(iox2_node_state_e node_state,
                          iox2_unique_node_id_ptr node_id_ptr,
                          const char* executable,
                          iox2_node_name_ptr node_name,
                          iox2_config_ptr config,
                          iox2_callback_context context) -> iox2_callback_progression_e {
    auto node_details = [&]() -> auto {
        if (node_id_ptr == nullptr || config == nullptr) {
            return bb::Optional<NodeDetails>();
        }
 
        auto str =
            iox2::bb::StaticString<iox2::bb::FileName::capacity()>::from_utf8_null_terminated_unchecked(executable);
        if (!str.has_value()) {
            return bb::Optional<NodeDetails>();
        }
        auto file_name = bb::FileName::create(*str);
        if (!file_name.has_value()) {
            IOX2_PANIC("The executable file name should always be valid.");
        }
        return bb::Optional<NodeDetails>(
            NodeDetails { file_name.value(), NodeNameView { node_name }.to_owned(), Config {} });
    }();
 
    iox2_unique_node_id_h node_id_handle = nullptr;
    iox2_unique_node_id_clone_from_ptr(nullptr, node_id_ptr, &node_id_handle);
    UniqueNodeId node_id { node_id_handle };
 
    auto node_state_object = [&]() -> auto {
        switch (node_state) {
        case iox2_node_state_e_ALIVE:
            return NodeState<T> { AliveNodeView<T> { node_id, node_details } };
        case iox2_node_state_e_DEAD:
            return NodeState<T> { DeadNodeView<T> { AliveNodeView<T> { node_id, node_details } } };
        case iox2_node_state_e_UNDEFINED:
            return NodeState<T> { iox2_node_state_e_UNDEFINED, node_id };
        case iox2_node_state_e_INACCESSIBLE:
            return NodeState<T> { iox2_node_state_e_INACCESSIBLE, node_id };
        }
 
        IOX2_UNREACHABLE();
    }();
 
    auto* callback = internal::ctx_cast<iox2::bb::StaticFunction<CallbackProgression(NodeState<T>)>>(context);
    return iox2::bb::into<iox2_callback_progression_e>(callback->value()(node_state_object));
}
// NOLINTEND(readability-function-size)
 
} // namespace internal
} // namespace iox2
 
#endif