server.hpp

Go to the documentation of this file.

// Copyright (c) 2025 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_SERVER_HPP
#define IOX2_SERVER_HPP
 
#include "iox2/active_request.hpp"
#include "iox2/bb/expected.hpp"
#include "iox2/bb/optional.hpp"
#include "iox2/bb/slice.hpp"
#include "iox2/service_type.hpp"
#include "iox2/unique_port_id.hpp"
 
namespace iox2 {
template <ServiceType Service,
          typename RequestPayload,
          typename RequestHeader,
          typename ResponsePayload,
          typename ResponseHeader>
class Server {
  public:
    Server(Server&& rhs) noexcept;
    auto operator=(Server&& rhs) noexcept -> Server&;
    ~Server() noexcept;
 
    Server(const Server&) noexcept = delete;
    auto operator=(const Server&) noexcept -> Server& = delete;
 
    auto receive() -> bb::Expected<
        bb::Optional<ActiveRequest<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>>,
        ReceiveError>;
 
    template <typename T = ResponsePayload, typename = std::enable_if_t<bb::IsSlice<T>::VALUE, void>>
    auto initial_max_slice_len() const -> uint64_t;
 
    auto id() const -> UniqueServerId;
 
    auto has_requests() const -> bb::Expected<bool, ConnectionFailure>;
 
  private:
    template <ServiceType, typename, typename, typename, typename>
    friend class PortFactoryServer;
 
    explicit Server(iox2_server_h handle) noexcept;
 
    void drop();
 
    iox2_server_h m_handle = nullptr;
};
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestHeader,
          typename ResponsePayload,
          typename ResponseHeader>
inline Server<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>::Server(Server&& rhs) noexcept {
    *this = std::move(rhs);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestHeader,
          typename ResponsePayload,
          typename ResponseHeader>
inline auto
Server<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>::operator=(Server&& rhs) noexcept
    -> Server& {
    if (this != &rhs) {
        drop();
        m_handle = rhs.m_handle;
        rhs.m_handle = nullptr;
    }
 
    return *this;
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestHeader,
          typename ResponsePayload,
          typename ResponseHeader>
inline Server<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>::~Server() noexcept {
    drop();
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestHeader,
          typename ResponsePayload,
          typename ResponseHeader>
inline auto Server<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>::receive() -> bb::Expected<
    bb::Optional<ActiveRequest<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>>,
    ReceiveError> {
    iox2_active_request_h active_request_handle {};
    auto result = iox2_server_receive(&m_handle, nullptr, &active_request_handle);
 
    if (result == IOX2_OK) {
        if (active_request_handle != nullptr) {
            ActiveRequest<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader> active_request(
                active_request_handle);
            return bb::Optional<ActiveRequest<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>>(
                std::move(active_request));
        }
        return bb::Optional<ActiveRequest<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>>(
            bb::NULLOPT);
    }
    return bb::err(bb::into<ReceiveError>(result));
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestHeader,
          typename ResponsePayload,
          typename ResponseHeader>
template <typename T, typename>
inline auto
Server<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>::initial_max_slice_len() const
    -> uint64_t {
    return iox2_server_initial_max_slice_len(&m_handle);
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestHeader,
          typename ResponsePayload,
          typename ResponseHeader>
inline auto Server<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>::id() const
    -> UniqueServerId {
    iox2_unique_server_id_h id_handle = nullptr;
    iox2_server_id(&m_handle, nullptr, &id_handle);
    return UniqueServerId { id_handle };
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestHeader,
          typename ResponsePayload,
          typename ResponseHeader>
inline auto Server<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>::has_requests() const
    -> bb::Expected<bool, ConnectionFailure> {
    bool has_requests_result = false;
    auto result = iox2_server_has_requests(&m_handle, &has_requests_result);
 
    if (result == IOX2_OK) {
        return has_requests_result;
    }
 
    return bb::err(bb::into<ConnectionFailure>(result));
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestHeader,
          typename ResponsePayload,
          typename ResponseHeader>
inline Server<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>::Server(
    iox2_server_h handle) noexcept
    : m_handle { handle } {
}
 
template <ServiceType Service,
          typename RequestPayload,
          typename RequestHeader,
          typename ResponsePayload,
          typename ResponseHeader>
inline void Server<Service, RequestPayload, RequestHeader, ResponsePayload, ResponseHeader>::drop() {
    if (m_handle != nullptr) {
        iox2_server_drop(m_handle);
        m_handle = nullptr;
    }
}
} // namespace iox2
#endif