adapterBase.hpp

Go to the documentation of this file.

 
#ifndef CAMCOM_COMMON_ADAPTERBASE_HPP
#define CAMCOM_COMMON_ADAPTERBASE_HPP
 
#include <string>
#include <vector>
#include <span>
#include <cmath>
#include <chrono>
#include <map>
#include <optional>
 
#include "camcom/common/receiveCfg.hpp"
#include "camcom/common/frameInfo.hpp"
#include "camcom/common/parameter.hpp"
#include "camcom/common/basicParams.hpp"
#include "camcom/common/tools.hpp"
 
namespace camcom::common {

    enum class AcqMode {
        Inactive,    
        Continuous,  
        Finite       
    };

    struct AcquisitionState {
        AcqMode mode{AcqMode::Inactive};
        std::optional<int64_t> remaining_frames;  
        double current_fps{0.0};                  
    };

    struct NativeDocument {
        std::string content;    
        std::string extension;  
        bool available() const { return !content.empty(); }
    };

    struct CheckResult {
        bool ok{false};
        std::vector<std::string> diagnostics;
    };
 
    // Abstract class for CamCom Communication Adapters.
    class AdapterBase {
    public:
        AdapterBase();
        virtual ~AdapterBase();
 
        // Connection management.
        //
        // Connect opens the link to the device and returns the initial
        // parameter set read from it (camera-native names). Throws on
        // failure (timeout, no device, bad credentials, ...).
        virtual std::map<std::string, Parameter> Connect() = 0;
        virtual void Disconnect() = 0;
        virtual CheckResult CheckConnection() const = 0;
 
        // Adapters own their own connection-state flag (typically inside
        // their pimpl `Impl`) and report it here. Pure virtual so there
        // is exactly ONE source of truth per adapter — no dual flags to
        // keep in sync, no risk of drift between base and impl.
        virtual bool IsConnected() const = 0;

        virtual std::string GetProtocol() const = 0;

        virtual BasicParams GetBasicParams() const = 0;
 
        // The address and timeout are mandatory parameters; any other required properties should
        // be included via the receiveCfg argument.
        virtual void Initialise(const ReceiveCfg& cfg);
 
        // Resolve a device address to an IP for transports that cannot do DNS
        // themselves (e.g. Aravis). Precedence: a literal IP is returned
        // unchanged; otherwise the address is resolved via DNS (IPv4 preferred,
        // then IPv6) and the resolved IP returned. If `allow_device_id` is true,
        // a non-IP that does not resolve is returned unchanged (so a GenICam
        // device id passes through to the SDK); if false, a non-IP that does not
        // resolve throws. An empty address is returned unchanged (auto-discovery).
        static std::string ResolveAddress(const std::string& address,
                                          bool allow_device_id = false);
 
        // Method to receive a frame.
        virtual void ReceiveFrame(bool& received_frame,
                                  uint64_t max_size,
                                  std::span<uint8_t>& data,
                                  FrameInfo& frame_info) = 0;

        virtual Parameter Read(const std::string& name) = 0;

        virtual std::vector<Parameter> Read(const std::vector<std::string>& names) = 0;

        virtual void Write(const Parameter& parameter) = 0;

        virtual void Write(const std::vector<Parameter>& parameters) = 0;

        virtual std::vector<Parameter> Scan() = 0;

        virtual NativeDocument GetNativeParameterDocument() const { return {}; }
 
        // Acquisition control

        virtual AcquisitionState GetAcquisitionState() const = 0;

        virtual void StartAcquisition(std::optional<int64_t> frame_count = std::nullopt) = 0;

        virtual void StopAcquisition() = 0;

        void SetAddress(const std::string& address) { m_cam_address = address; }

        void SetTimeout(double timeout_seconds) {
            m_timeout = std::chrono::duration<double_t>(timeout_seconds);
        }
 
    protected:
        const std::chrono::duration<double_t> m_connect_timeout{std::chrono::seconds(10)};
 
        std::string                     m_cam_address;
        std::chrono::duration<double_t> m_timeout;
        bool                            m_initialised{false};
        std::chrono::time_point<std::chrono::system_clock>
            m_time_last_stop{common::TimeNow()},
            m_time_last_frame_recv{m_time_last_stop};
        bool m_waiting_for_frame{false};
    };
 
} // namespace camcom::common
 
#endif