iox-eclipse-iceoryx#27-1: client port user skeleton

Signed-off-by: Poehnl Michael (CC-AD/ESW1) <[email protected]>

Author: Poehnl Michael (CC-AD/ESW1)

iceoryx_posh/CMakeLists.txt

@@ -84,7 +84,8 @@ add_library(iceoryx_posh
     source/popo/ports/subscriber_port_multi_producer.cpp
     source/popo/ports/subscriber_port_data.cpp
     source/popo/ports/client_port_data.cpp
-    source/popo/ports/client_port_roudi.cpp    
+    source/popo/ports/client_port_roudi.cpp
+    source/popo/ports/client_port_user.cpp        
     source/popo/ports/server_port_data.cpp
     source/popo/ports/server_port_roudi.cpp      
     source/popo/building_blocks/chunk_queue_types.cpp

iceoryx_posh/include/iceoryx_posh/internal/popo/ports/client_port_user.hpp

@@ -0,0 +1,117 @@
+// Copyright (c) 2020 by Robert Bosch GmbH. All rights reserved.
+//
+// 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 IOX_POSH_POPO_PORTS_CLIENT_PORT_USER_HPP
+#define IOX_POSH_POPO_PORTS_CLIENT_PORT_USER_HPP
+
+#include "iceoryx_posh/internal/popo/building_blocks/chunk_receiver.hpp"
+#include "iceoryx_posh/internal/popo/building_blocks/chunk_sender.hpp"
+#include "iceoryx_posh/internal/popo/ports/base_port.hpp"
+#include "iceoryx_posh/internal/popo/ports/client_port_data.hpp"
+#include "iceoryx_posh/mepoo/chunk_header.hpp"
+#include "iceoryx_utils/cxx/expected.hpp"
+#include "iceoryx_utils/cxx/helplets.hpp"
+#include "iceoryx_utils/cxx/optional.hpp"
+#include "iceoryx_utils/error_handling/error_handling.hpp"
+
+namespace iox
+{
+namespace popo
+{
+/// @brief The ClientPortUser provides the API for accessing a client port from the user side. The client port
+/// is divided in the three parts ClientPortData, ClientPortRouDi and ClientPortUser. The ClientPortUser
+/// uses the functionality of a ChunkSender and ChunReceiver for sending requests and receiving responses.
+/// Additionally it provides the connect / disconnect API which controls whether the client port shall connect to the
+/// server
+class ClientPortUser : public BasePort
+{
+  public:
+    using MemberType_t = ClientPortData;
+
+    explicit ClientPortUser(cxx::not_null<MemberType_t* const> clientPortDataPtr) noexcept;
+
+    ClientPortUser(const ClientPortUser& other) = delete;
+    ClientPortUser& operator=(const ClientPortUser&) = delete;
+    ClientPortUser(ClientPortUser&& rhs) = default;
+    ClientPortUser& operator=(ClientPortUser&& rhs) = default;
+    ~ClientPortUser() = default;
+
+    /// @brief Allocate a chunk, the ownerhip of the SharedChunk remains in the ClientPortUser for being able to
+    /// cleanup if the user process disappears
+    /// @param[in] payloadSize, size of the user paylaod without additional headers
+    /// @return on success pointer to a ChunkHeader which can be used to access the payload and header fields, error if
+    /// not
+    cxx::expected<mepoo::ChunkHeader*, AllocationError> allocateRequestChunk(const uint32_t payloadSize) noexcept;
+
+    /// @brief Free an allocated chunk without sending it
+    /// @param[in] chunkHeader, pointer to the ChunkHeader to free
+    void freeRequestChunk(mepoo::ChunkHeader* const chunkHeader) noexcept;
+
+    /// @brief Send an allocated request chunk to the server port
+    /// @param[in] chunkHeader, pointer to the ChunkHeader to send
+    void sendRequestChunk(mepoo::ChunkHeader* const chunkHeader) noexcept;
+
+    /// @brief try to connect to the server
+    void connect() noexcept;
+
+    /// @brief disconnect from the server
+    void disconnect() noexcept;
+
+    /// @brief get the current connection state. Caution: There can be delays between calling connect and a change
+    /// in the conenction state. The connection state can also change without user interaction if the server comes
+    /// and goes
+    /// @return ConnectionState
+    ConnectionState getConnectionState() const noexcept;
+
+    /// @brief Tries to get the next response from the queue. If there is a new one, the ChunkHeader of the oldest
+    /// response in the queue is returned (FiFo queue)
+    /// @return optional that has a new chunk header or no value if there are no new responses in the underlying queue,
+    /// ChunkReceiveError on error
+    cxx::expected<cxx::optional<const mepoo::ChunkHeader*>, ChunkReceiveError> getResponseChunk() noexcept;
+
+    /// @brief Release a response that was obtained with getResponseChunk
+    /// @param[in] chunkHeader, pointer to the ChunkHeader to release
+    void releaseResponseChunk(const mepoo::ChunkHeader* chunkHeader) noexcept;
+
+    /// @brief check if there are responses in the queue
+    /// @return if there are responses in the queue return true, otherwise false
+    bool hasNewResponseChunks() noexcept;
+
+    /// @brief check if there was a queue overflow since the last call of hasLostResponseChunks
+    /// @return true if the underlying queue overflowed since last call of this method, otherwise false
+    bool hasLostResponseChunks() noexcept;
+
+    /// @brief set a condition variable (via its pointer) to the client
+    /// @return true if attachment worked, otherwise false
+    bool setConditionVariable(ConditionVariableData* conditionVariableDataPtr) noexcept;
+
+    /// @brief unset a condition variable from the client
+    /// @return true if detachment worked, otherwise false
+    bool unsetConditionVariable() noexcept;
+
+    /// @brief check if there's a condition variable set
+    /// @return true if a condition variable attached, otherwise false
+    bool isConditionVariableSet() noexcept;
+
+  private:
+    const MemberType_t* getMembers() const noexcept;
+    MemberType_t* getMembers() noexcept;
+
+    ChunkSender<ClientChunkSenderData_t> m_chunkSender;
+    ChunkReceiver<ClientChunkReceiverData_t> m_chunkReceiver;
+};
+
+} // namespace popo
+} // namespace iox
+
+#endif // IOX_POSH_POPO_PORTS_PUBLISHER_PORT_USER_HPP

iceoryx_posh/include/iceoryx_posh/internal/popo/ports/subscriber_port_user.hpp

@@ -16,6 +16,7 @@
 #define IOX_POPO_SUBSCRIBER_PORT_USER_HPP_
 
 #include "iceoryx_posh/internal/popo/building_blocks/chunk_receiver.hpp"
+#include "iceoryx_posh/internal/popo/ports/base_port.hpp"
 #include "iceoryx_posh/internal/popo/ports/subscriber_port_data.hpp"
 #include "iceoryx_posh/mepoo/chunk_header.hpp"
 #include "iceoryx_utils/cxx/expected.hpp"
@@ -32,7 +33,7 @@ namespace popo
 /// The SubscriberPortUser uses the functionality of a ChunkReceiver for receiving shared memory chunks. Additionally it
 /// provides the subscribe / unsubscribe API which controls whether the subscriber ports shall try to subscribe to
 /// matching publisher ports
-class SubscriberPortUser
+class SubscriberPortUser : public BasePort
 {
   public:
     using MemberType_t = SubscriberPortData;
@@ -96,8 +97,6 @@ class SubscriberPortUser
     const MemberType_t* getMembers() const noexcept;
     MemberType_t* getMembers() noexcept;
 
-    MemberType_t* m_subscriberPortDataPtr;
-
     ChunkReceiver<SubscriberPortData::ChunkReceiverData_t> m_chunkReceiver;
 };
 

iceoryx_posh/source/popo/ports/client_port_roudi.cpp

@@ -38,13 +38,17 @@ ClientPortRouDi::MemberType_t* ClientPortRouDi::getMembers() noexcept
 
 cxx::optional<capro::CaproMessage> ClientPortRouDi::getCaProMessage() noexcept
 {
+    /// @todo
+
     // nothing to change
     return cxx::nullopt_t();
 }
 
 cxx::optional<capro::CaproMessage>
 ClientPortRouDi::dispatchCaProMessage(const capro::CaproMessage& caProMessage) noexcept
 {
+    /// @todo
+    
     capro::CaproMessage responseMessage(
         capro::CaproMessageType::NACK, this->getCaProServiceDescription(), capro::CaproMessageSubType::NOSUBTYPE);
 

iceoryx_posh/source/popo/ports/client_port_user.cpp

@@ -0,0 +1,106 @@
+// Copyright (c) 2020 by Robert Bosch GmbH. All rights reserved.
+//
+// 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
+
+#include "iceoryx_posh/internal/popo/ports/client_port_user.hpp"
+
+namespace iox
+{
+namespace popo
+{
+ClientPortUser::ClientPortUser(cxx::not_null<MemberType_t* const> clientPortDataPtr) noexcept
+    : BasePort(clientPortDataPtr)
+    , m_chunkSender(&getMembers()->m_chunkSenderData)
+    , m_chunkReceiver(&getMembers()->m_chunkReceiverData)
+
+{
+}
+
+const ClientPortUser::MemberType_t* ClientPortUser::getMembers() const noexcept
+{
+    return reinterpret_cast<const MemberType_t*>(BasePort::getMembers());
+}
+
+ClientPortUser::MemberType_t* ClientPortUser::getMembers() noexcept
+{
+    return reinterpret_cast<MemberType_t*>(BasePort::getMembers());
+}
+
+cxx::expected<mepoo::ChunkHeader*, AllocationError>
+ClientPortUser::allocateRequestChunk(const uint32_t payloadSize) noexcept
+{
+    return m_chunkSender.allocate(payloadSize, getUniqueID());
+}
+
+void ClientPortUser::freeRequestChunk(mepoo::ChunkHeader* const chunkHeader) noexcept
+{
+    m_chunkSender.release(chunkHeader);
+}
+
+void ClientPortUser::sendRequestChunk(mepoo::ChunkHeader* const chunkHeader) noexcept
+{
+    /// @todo
+}
+
+void ClientPortUser::connect() noexcept
+{
+    /// @todo
+}
+
+void ClientPortUser::disconnect() noexcept
+{
+    /// @todo
+}
+
+ConnectionState ClientPortUser::getConnectionState() const noexcept
+{
+    return getMembers()->m_connectionState;
+}
+
+cxx::expected<cxx::optional<const mepoo::ChunkHeader*>, ChunkReceiveError> ClientPortUser::getResponseChunk() noexcept
+{
+    return m_chunkReceiver.get();
+}
+
+void ClientPortUser::releaseResponseChunk(const mepoo::ChunkHeader* chunkHeader) noexcept
+{
+    m_chunkReceiver.release(chunkHeader);
+}
+
+bool ClientPortUser::hasNewResponseChunks() noexcept
+{
+    return !m_chunkReceiver.empty();
+}
+
+bool ClientPortUser::hasLostResponseChunks() noexcept
+{
+    return m_chunkReceiver.hasOverflown();
+}
+
+bool ClientPortUser::setConditionVariable(ConditionVariableData* conditionVariableDataPtr) noexcept
+{
+    return m_chunkReceiver.attachConditionVariable(conditionVariableDataPtr);
+}
+
+bool ClientPortUser::unsetConditionVariable() noexcept
+{
+    return m_chunkReceiver.detachConditionVariable();
+}
+
+bool ClientPortUser::isConditionVariableSet() noexcept
+{
+    return m_chunkReceiver.isConditionVariableAttached();
+}
+
+} // namespace popo
+} // namespace iox

iceoryx_posh/source/popo/ports/publisher_port_user.cpp

@@ -20,20 +20,19 @@ namespace popo
 {
 PublisherPortUser::PublisherPortUser(cxx::not_null<MemberType_t* const> publisherPortDataPtr) noexcept
     : BasePort(publisherPortDataPtr)
-    , m_publisherPortDataPtr(publisherPortDataPtr)
-    , m_chunkSender(&m_publisherPortDataPtr->m_chunkSenderData)
+    , m_chunkSender(&getMembers()->m_chunkSenderData)
 
 {
 }
 
 const PublisherPortUser::MemberType_t* PublisherPortUser::getMembers() const noexcept
 {
-    return m_publisherPortDataPtr;
+    return reinterpret_cast<const MemberType_t*>(BasePort::getMembers());
 }
 
 PublisherPortUser::MemberType_t* PublisherPortUser::getMembers() noexcept
 {
-    return m_publisherPortDataPtr;
+    return reinterpret_cast<MemberType_t*>(BasePort::getMembers());
 }
 
 cxx::expected<mepoo::ChunkHeader*, AllocationError>

iceoryx_posh/source/popo/ports/subscriber_port_user.cpp

@@ -20,20 +20,20 @@ namespace iox
 namespace popo
 {
 SubscriberPortUser::SubscriberPortUser(cxx::not_null<MemberType_t* const> subscriberPortDataPtr) noexcept
-    : m_subscriberPortDataPtr(subscriberPortDataPtr)
-    , m_chunkReceiver(&m_subscriberPortDataPtr->m_chunkReceiverData)
+    : BasePort(subscriberPortDataPtr)
+    , m_chunkReceiver(&getMembers()->m_chunkReceiverData)
 
 {
 }
 
 const SubscriberPortUser::MemberType_t* SubscriberPortUser::getMembers() const noexcept
 {
-    return m_subscriberPortDataPtr;
+    return reinterpret_cast<const MemberType_t*>(BasePort::getMembers());
 }
 
 SubscriberPortUser::MemberType_t* SubscriberPortUser::getMembers() noexcept
 {
-    return m_subscriberPortDataPtr;
+    return reinterpret_cast<MemberType_t*>(BasePort::getMembers());
 }