AbstractNIC.hxx

Go to the documentation of this file.

//
// Created by Zhiping Jiang on 12/26/19.
//
 
#ifndef PICOSCENES_PLATFORM_ABSTRACTNIC_HXX
#define PICOSCENES_PLATFORM_ABSTRACTNIC_HXX
 
#include "AsyncPipeline.hxx"
#include "TaggedThreadPool.hxx"
#include "LoggingService.hxx"
#include "AbstractHALConfiguration.hxx"
#include "FrontEndFactory.hxx"
#include "PicoScenesPluginManager.hxx"
 
using namespace std::chrono_literals;
 
class AbstractHALConfiguration;
 
class PicoScenesPluginManager;
 
class AbstractNIC : public std::enable_shared_from_this<AbstractNIC> {
public:
 
    virtual void startTxService() = 0;
 
    virtual void stopTxService() = 0;
 
    virtual void pauseTx() = 0;
 
    virtual void resumeTx() = 0;
 
    virtual bool isTxServiceStarted() const = 0;
 
    virtual int transmitPicoScenesFrame(const ModularPicoScenesTxFrame &frame) = 0;
 
    virtual int transmitPicoScenesFrameSync(const ModularPicoScenesTxFrame &frame) = 0;
 
    virtual int transmitFramesInBatch(const std::vector<ModularPicoScenesTxFrame> &frames, uint16_t numRepeats) = 0;
 
    template<int repeat = 1, typename ... Frames, typename = std::enable_if_t<(std::is_same_v<std::remove_cvref_t<Frames>, ModularPicoScenesTxFrame *> &&...) ||
                                                                              (std::is_same_v<std::remove_cvref_t<Frames>, ModularPicoScenesTxFrame>  &&...) ||
                                                                              ((std::is_same_v<std::remove_cvref_t<Frames>, std::shared_ptr<ModularPicoScenesTxFrame>> ||
                                                                                std::is_same_v<std::remove_cvref_t<Frames>, std::unique_ptr<ModularPicoScenesTxFrame>>) &&...)>>
    int transmitFramesInBatch(Frames &&... frames) {
        std::vector<ModularPicoScenesTxFrame> batchFrames;
 
        if constexpr (((std::is_same_v<std::remove_cvref_t<Frames>, ModularPicoScenesTxFrame *> ||
                        std::is_same_v<std::remove_cvref_t<Frames>, std::shared_ptr<ModularPicoScenesTxFrame>> ||
                        std::is_same_v<std::remove_cvref_t<Frames>, std::unique_ptr<ModularPicoScenesTxFrame>>) && ...)) {
            (batchFrames.emplace_back(*frames), ...);
        } else if constexpr ((std::is_same_v<std::remove_cvref_t<Frames>, ModularPicoScenesTxFrame> && ...)) {
            (batchFrames.emplace_back(frames), ...);
        }
        return transmitFramesInBatch(batchFrames, repeat);
    }
 
    virtual ModularPicoScenesTxFrame initializeTxFrame() {
        return frontEnd->initializeTxFrame();
    }
 
//    int transmitTest(const ModularPicoScenesTxFrame &frame1, const ModularPicoScenesTxFrame &frame2) {
//        ModularPicoScenesTxFrame t1, t2, t3;
//        auto t4 = std::make_shared<ModularPicoScenesTxFrame>();
//        auto t5 = std::make_shared<ModularPicoScenesTxFrame>();
//        auto t6 = std::make_unique<ModularPicoScenesTxFrame>();
//        auto t7 = std::make_unique<ModularPicoScenesTxFrame>();
//        transmitFramesInBatch(t4, t6);
//        transmitFramesInBatch(t6, t7);
//        transmitFramesInBatch(t1, t2, t3);
//        return transmitFramesInBatch(frame1, frame2);
//    }
 
    virtual void startRxService() = 0;
 
    virtual void stopRxService() = 0;
 
    virtual void pauseRx() = 0;
 
    virtual void resumeRx() = 0;
 
    virtual bool isRxServiceStarted() const = 0;
 
    virtual std::optional<ModularPicoScenesRxFrame> syncRxConditionally(const std::function<bool(const ModularPicoScenesRxFrame &)> &condition, const std::chrono::milliseconds &maxWait_ms, std::optional<std::string> conditionaName = std::nullopt) = 0;
 
    virtual std::optional<ModularPicoScenesRxFrame> syncRxWaitTaskId(uint16_t taskid, uint32_t maxWait_ms) = 0;
 
    virtual void registerTaskIdHandler(uint16_t taskId, const std::function<bool(const ModularPicoScenesRxFrame &)> &handle) = 0;
 
    virtual std::function<bool(const ModularPicoScenesRxFrame &)> getHandlerForFrameType(uint8_t frameType) = 0;
 
    virtual void unregisterTaskIdHandler(uint16_t taskId) = 0;
 
    virtual bool checkTaskIdHandlerExist(uint16_t taskId) = 0;
 
    virtual void registerFrameTypeHandler(uint8_t frameType, const std::function<bool(const ModularPicoScenesRxFrame &)> &handle) = 0;
 
    virtual std::function<bool(const ModularPicoScenesRxFrame &)> getHandlerForTaskId(uint16_t taskId) = 0;
 
    virtual void unregisterFrameTypeHandler(uint8_t frameType) = 0;
 
    virtual bool checkFrameTypeHandlerExist(uint8_t frameType) = 0;
 
    virtual void registerGeneralHandler(const std::string &handlerKeyName, const std::function<bool(const ModularPicoScenesRxFrame &)> &handle) = 0;
 
    virtual std::function<bool(const ModularPicoScenesRxFrame &)> getGeneralHandler(const std::string &handlerKeyName) = 0;
 
    virtual void unregisterGeneralHandler(const std::string &handlerKeyName) = 0;
 
    virtual bool checkGeneralHandlerExist(const std::string &handlerKeyName) = 0;
 
    const std::string &getReferredInterfaceName() const;
 
    const std::string &getPhyId() const;
 
    const std::shared_ptr<AbstractFrontEnd> &getFrontEnd() const;
 
    virtual const PicoScenesFrameTxParameters &getUserSpecifiedTxParameters() const = 0;
 
    virtual PicoScenesFrameTxParameters &getUserSpecifiedTxParameters() = 0;
 
    PicoScenesDeviceType getDeviceType() const;
 
    std::shared_ptr<AbstractHALConfiguration> getConfiguration() const;
 
    template<typename FrontEndT, class = std::enable_if_t<std::is_base_of_v<AbstractFrontEnd, FrontEndT>>>
    std::shared_ptr<FrontEndT> getTypedFrontEnd() const {
        return FrontEndFactory::getTypedFrontEndInstance<FrontEndT>(getReferredInterfaceName());
    }
 
    const std::shared_ptr<PicoScenesPluginManager> &getPluginManager() const;
 
    virtual void installPlugins() const = 0;
 
    std::vector<std::shared_ptr<po::options_description>> getAllNICOptions();
 
protected:
    std::string referredInterfaceName;
 
    std::string phyId;
 
    PicoScenesDeviceType deviceType = PicoScenesDeviceType::Unknown;
 
    std::shared_ptr<AbstractHALConfiguration> configuration;
 
    std::shared_ptr<AbstractFrontEnd> frontEnd;
 
    std::shared_ptr<PicoScenesPluginManager> pluginManager;
 
    explicit AbstractNIC(const std::string &referredInterfaceName);
};
 
 
#endif //PICOSCENES_PLATFORM_ABSTRACTNIC_HXX