payload.h

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <vector>
 
#include <flyby/drone/drone.h>
#include <flyby/payload/component/component.h>
 
namespace flyby {
    class Camera;
    class IRCamera;
    class GimbalInterface;
    class LRFInterface;
    class StreamInterface;
 
    class PayloadInterface : public Component {
    public:
        friend class ComponentHandler;
 
        virtual void register_stream(std::shared_ptr<StreamInterface> stream) = 0;
 
        virtual void register_gimbal(std::shared_ptr<GimbalInterface> gimbal) = 0;
 
        virtual void register_lrf(std::shared_ptr<LRFInterface> lrf) = 0;
 
        [[nodiscard]] virtual std::string get_version() const = 0;
 
        [[nodiscard]] virtual unsigned int get_port() const = 0;
 
        [[nodiscard]] virtual const std::vector<std::shared_ptr<const StreamInterface>>& get_streams_const() const = 0;
 
        [[nodiscard]] virtual const std::vector<std::shared_ptr<const GimbalInterface>>& get_gimbals_const() const = 0;
 
        [[nodiscard]] virtual const std::vector<std::shared_ptr<const LRFInterface>>& get_lrfs_const() const = 0;
 
    protected:
        using Component::Component;
 
    private:
        virtual void set_port(unsigned int port) = 0;
 
        virtual std::vector<std::shared_ptr<StreamInterface>>& get_streams() = 0;
        virtual std::vector<std::shared_ptr<GimbalInterface>>& get_gimbals() = 0;
        virtual std::vector<std::shared_ptr<LRFInterface>>& get_lrfs() = 0;
 
        virtual std::shared_ptr<StreamInterface> get_active_stream() = 0;
        virtual std::shared_ptr<GimbalInterface> get_active_gimbal() = 0;
        virtual std::shared_ptr<LRFInterface> get_active_lrf() = 0;
    };
 
    class Payload : public PayloadInterface {
    public:
        Payload(const std::string& name, const std::string& version);
 
        Payload(const std::string& name, const std::string& version, unsigned int port, const std::string& uuid);
 
        ~Payload() override;
 
        void register_stream(std::shared_ptr<StreamInterface> stream) final;
 
        void register_gimbal(std::shared_ptr<GimbalInterface> gimbal) final;
 
        void register_lrf(std::shared_ptr<LRFInterface> lrf) final;
 
        [[nodiscard]] std::string get_version() const final;
 
        [[nodiscard]] unsigned int get_port() const final;
 
        [[nodiscard]] const std::vector<std::shared_ptr<const StreamInterface>>& get_streams_const() const final;
 
        [[nodiscard]] const std::vector<std::shared_ptr<const GimbalInterface>>& get_gimbals_const() const final;
 
        [[nodiscard]] const std::vector<std::shared_ptr<const LRFInterface>>& get_lrfs_const() const final;
 
    private:
        std::string m_version;
 
        unsigned int m_port;
 
        unsigned int m_active_stream_idx;
        unsigned int m_active_gimbal_idx;
        unsigned int m_active_lrf_idx;
 
        std::vector<std::shared_ptr<StreamInterface>> m_streams;
        std::vector<std::shared_ptr<GimbalInterface>> m_gimbals;
        std::vector<std::shared_ptr<LRFInterface>> m_lrfs;
 
        void set_port(unsigned int port) final;
 
        std::vector<std::shared_ptr<StreamInterface>>& get_streams() final;
        std::vector<std::shared_ptr<GimbalInterface>>& get_gimbals() final;
        std::vector<std::shared_ptr<LRFInterface>>& get_lrfs() final;
 
        std::shared_ptr<StreamInterface> get_active_stream() final;
        std::shared_ptr<GimbalInterface> get_active_gimbal() final;
        std::shared_ptr<LRFInterface> get_active_lrf() final;
    };
}