BaosConnection.h

Go to the documentation of this file.

//
// Copyright (c) 2002-2026 WEINZIERL ENGINEERING GmbH
// All rights reserved.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
// SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY,
// WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE
//
 
#ifndef __BAOSLIB_CONNECTION_H__
#define __BAOSLIB_CONNECTION_H__
 
#include "baos/config.h"
#include "baos/connection/IOEvent.h"
#include "baos/ip/IpGeneral.h"
#include "baos/protocol/Defines.h"
#include "baos/protocol/Response.h"
 
#include "connection/BaosIndicationSender.h"
 
#include "wzcpp/features/concurrent/executor.h"
#include "wzcpp/features/timer/timer.h"
 
#include <future>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <string>
 
namespace wz::baos
{
 
enum class BaosParseStatus
{
    Success,
    SizeMismatch,
    InvalidKnxHeader,
    InvalidConnectionHeader,
    InvalidMsgData,
    InvalidMainService,
    InvalidSubService,
    UnknownIndicationType,
    MalformedResponse
};
 
std::string BAOSLIB_EXPORT
parseStatusToString(BaosParseStatus parseStatus);  
 
class BAOSLIB_EXPORT BaosConnection
{
public:
    using Clock          = std::chrono::system_clock;  
    using BaosFrame      = Buffer;  
    using BaosFrame_UPtr = std::unique_ptr<BaosFrame>;       
    using UPtr           = std::unique_ptr<BaosConnection>;  
    using ConnectionEventCb      = std::function<void(ConnectionEvent&)>;  
    using ServerItemIndicationCb =
        std::function<void(const protocol::ServerItems&)>;  
    using DatapointValueCb = std::function<void(
        const protocol::DatapointValueStates&)>;  
 
    BaosConnection();           
    virtual ~BaosConnection();  
 
    void start();  
    void stop();   
 
    virtual void reopen() = 0;  
    void close();               
 
    bool isOpen();
 
 
 
    std::optional<protocol::ServerItem> getServerItem(protocol::ServerItemId id); 
    protocol::ServerItems getServerItems(std::uint16_t startItem, std::uint16_t numberOfItems);
 
    void setServerItem(const protocol::ServerItem& serverItem); 
    void setServerItem(protocol::ServerItem&& serverItem);      
    void setServerItems(protocol::ServerItems&& serverItems);   
    std::optional<protocol::DatapointDescription> getDpDescription(std::uint16_t dpId);
 
    protocol::DatapointDescriptions getDpDescriptions(std::uint16_t startDpId, std::uint16_t numberOfItems);
 
    std::optional<protocol::DatapointDescriptionString> getDpDescriptionString(std::uint16_t dpId);
 
    protocol::DatapointDescriptionStrings getDpDescriptionStrings(std::uint16_t startDpId,
                                                                  std::uint16_t numberOfStrings);
 
    std::optional<std::uint8_t> getParameterByte(std::uint16_t byteIndex);  
 
    protocol::ParameterBytes getParameterBytes(std::uint16_t byteIndex, std::uint16_t numberOfBytes);
 
    std::optional<protocol::DatapointValueState> getDpValue(
        std::uint16_t dpId);  
 
    protocol::DatapointValueStates getDpValues(
        std::uint16_t startDpId,
        std::uint16_t numberOfValues,
        protocol::DatapointValueFilter filter = protocol::DatapointValueFilter::ALL);
 
    void setDpValue(std::uint16_t dpId, protocol::DatapointChangeValue&& dpValue);
 
 
    void setDpValues(std::map<std::uint16_t, protocol::DatapointChangeValue>&& dpValues);
 
    /******************************************************************************************************************/
    protocol::ResponseFuture getServerItemAsync(
        protocol::ServerItemId id); 
    protocol::ResponseFuture getServerItemsAsync(std::uint16_t startItem, std::uint16_t numberOfItems);
 
    protocol::ResponseFuture setServerItemAsync(protocol::ServerItem&& serverItem);    
    protocol::ResponseFuture setServerItemsAsync(protocol::ServerItems&& serverItems); 
    protocol::ResponseFuture getDpDescriptionAsync(std::uint16_t dpId);
 
    protocol::ResponseFuture getDpDescriptionsAsync(std::uint16_t startDpId, std::uint16_t numberOfItems);
 
    protocol::ResponseFuture getDpDescriptionStringAsync(std::uint16_t dpId);
 
    protocol::ResponseFuture getDpDescriptionStringsAsync(std::uint16_t startDpId, std::uint16_t numberOfStrings);
 
    protocol::ResponseFuture getParameterByteAsync(std::uint16_t byteIndex);  
 
    protocol::ResponseFuture getParameterBytesAsync(std::uint16_t byteIndex, std::uint16_t numberOfBytes);
 
    protocol::ResponseFuture getDpValueAsync(
        std::uint16_t dpId);  
 
    protocol::ResponseFuture getDpValuesAsync(
        std::uint16_t startDpId,
        std::uint16_t numberOfValues,
        protocol::DatapointValueFilter filter = protocol::DatapointValueFilter::ALL);
 
 
    protocol::ResponseFuture setDpValueAsync(std::uint16_t dpId, protocol::DatapointChangeValue&& dpValue);
 
    protocol::ResponseFuture setDpValuesAsync(std::map<std::uint16_t, protocol::DatapointChangeValue>&& dpValues);
 
    protocol::ResponseFuture closeAsync();
 
 
 
    void setConnectionEventCallback(ConnectionEventCb callback);
    
    void setServerItemsIndCallback(ServerItemIndicationCb callback);
 
    void setDatapointValueIndCallback(DatapointValueCb callback);
 
protected:
    protocol::ResponseFuture send(BaosFrame&& frame);
 
protected:
    enum class State
    {
        // States for our worker
        RUNNING,       
        STOPPING,      
        STOPPED,       
        
        // States for baos transport connection
 
        CONOPENING,     
 
        SENDING,       
        SENDCOMPLETE,  
        WAITRESPONSE,  
        IDLE,          
        
        CONCLOSING,    
        CONERROR,      
        CONCLOSED,      
        CONCLOSED_BY_ERROR, 
        FATALERROR   
    };
 
    enum class PromiseState
    {
        UNUSED,
        SET,
        RESOLVED
    };
 
    static std::string stateToString(State state);  
 
    BaosParseStatus handleBaosFrame(BaosFrame_UPtr&& frame);
 
    BaosParseStatus handleBaosIndication(BaosFrame_UPtr&& frame);
 
    protocol::BaosResponseCode handleBaosResponse(BaosFrame_UPtr&& frame);
 
    State setState(State newState);
 
    State getState() const;
 
    protocol::BaosBaseResponse::SPtr decodeResponse(BaosFrame_UPtr&& frame);
 
    virtual protocol::ResponseFuture closeImplAsync();  
    virtual void startImpl();  
    virtual void stopImpl();   
 
    virtual bool isOpenImpl();
 
    virtual protocol::ResponseFuture sendImpl(
        BaosFrame&& frame) = 0;  
 
    virtual void onStateChange(State oldState,
                               State newState);  
    
    void emitConnectionEvent(State oldState, State newState);
    void emitConnectionEvent(ConnectionEvent::Type event);
 
    virtual void onTimerExpired(std::vector<std::uint64_t> ids);  
 
    ConnectionEvent::Type getConnectionEvent(State state);
 
protected:
    std::atomic<bool> shouldStop_{false};  
 
    std::atomic<bool> isRunning_{false};
    wzcpp::ThreadPoolExecutor executor_{5};  
 
    wzcpp::TimerManager<Clock> timerManager_;  
    wzcpp::Timer<Clock> respTimeoutTimer_;     
    wzcpp::Timer<Clock> heartBeatTimer_;       
 
    Buffer waitResponse_;  
    protocol::ResponsePromise
        responsePromise_;  
    PromiseState responsePromiseState_{PromiseState::UNUSED};  
    std::uint64_t currentMessageId_{0};                        
    std::queue<IOEvent> txQueue_;                              
    BaosMsgQueue bMsgQ_;                                       
    BaosIndQueue bIndQ_;                                       
    BaosIndicationSender indSender_;                           
 
private:
    State state_{State::STOPPED};  
    mutable std::mutex stateMutex_;
};
 
}  // namespace wz::baos
 
#endif  // __BAOSLIB_CONNECTION_H__