comAdptBase.hpp

Go to the documentation of this file.

 
#ifndef CCF_COMMON_COM_ADPT_BASE_HPP_H_
#define CCF_COMMON_COM_ADPT_BASE_HPP_H_
 
#include <ctd/param/Parameter.hpp>
 
#include <ccf/common/base.hpp>
#include <ccf/common/dataFrame.hpp>
#include <ccf/common/nameMapping.hpp>
#include <ccf/common/configBase.hpp>
#include <ccf/common/db.hpp>
 
// TODO: Check if some of the methods are missing "const" declaration.
 
namespace ccf::common {
 
  std::string GetHostAddress();
 
  class ComAdptBase: public Base {
  public:
 
    ComAdptBase();
    virtual ~ComAdptBase();
 
    ccf::common::ConfigBase& Cfg();
 
    const std::string& GetCameraAddress() const;
 
    const std::string& GetId() const;
 
    void SetHostAdddress(const std::string& host_address);
 
    const std::string& GetHostAddress();
 
    void SetIsSimAdapter(const bool is_sim);
 
    bool GetIsSimAdapter() const;
 
    void SetProtocol(const std::string& protocol);
 
    const std::string& GetProtocol() const;
 
    template <class TYPE>
    TYPE GetCameraProperty(const std::string& property) {
      CCFTRACE;
      std::string tmp_value;
      if (HasCameraProperty(property, tmp_value)) {
        TYPE ret_value;
        ctd::conversion::Convert(tmp_value, ret_value);
        return ret_value;
      } else {
        CCFTHROW("Requesting undefined camera property: " + property);
      }
    }
 
    bool HasCameraProperty(const std::string& property,
                           std::string& value);
 
    double GetTheoreticFrameRate();
 
    void LoadCameraNameMapping(const std::string& name_mapping_file);
 
    void Initialise(const bool re_init = false);
 
    void SetCameraAddress(const std::string& address);
 
    void CheckConnection(bool& connected);
 
    void CheckStatus(ccf::common::HwStatus& status,
                     std::string& message);
 
    bool IsConnected() const;
 
    // Connect to the camera. If already connected, it will disconnect and reconnect.
    void Connect();
 
    void Disconnect();
 
    void WriteAdapterProps();
 
    virtual void WriteAdapterPropsUser();
 
    void SetIsConnected(const bool connected);
 
    bool GetAllowLostFrames() const;
 
    uint64_t IncLostFramesCount();
 
    uint64_t GetLostFramesCount() const;
 
    void ResetLostFramesCount();
 
    void Read(const std::string& name,
              ctd::param::Parameter& par);
 
    void Read(const std::vector<std::string>& names,
              std::vector<ctd::param::Parameter>& pars);
 
    std::string Read(const std::string& name);
 
    template <class TYPE>
    TYPE Read(const std::string& name) {
      CCFTRACE;
      ctd::param::Parameter par;
      Read(name, par);
      TYPE native_value;
      ctd::conversion::Convert(par.GetValue(), native_value);
      return native_value;
    }
 
    void Write(const ctd::param::Parameter& par);
 
    void Write(const std::vector<ctd::param::Parameter>& pars);
 
    template <class TYPE>
    void Write(const std::string& name, const TYPE& value) {
      CCFTRACE;
      ctd::param::Parameter tmp_par(name, value);
      Write(tmp_par);
    }
 
    void Receive(ccf::common::DataFrame& frame,
                 bool& frame_received,
                 const double timeout,
                 bool& timed_out);
 
    void Scan(std::vector<ctd::param::Parameter>& pars);
 
    void Start();
 
    void Stop();
 
    void HandleSetup();
 
    void HandleParPreWrite(ctd::param::Parameter& par);
 
    void HandleParPostWrite(ctd::param::Parameter& par);
 
    void HandleParPostRead(ctd::param::Parameter& par);
 
    void MapParForDevice(ctd::param::Parameter& par) const;
 
    void MapParFromDevice(ctd::param::Parameter& par) const;
 
    bool HasNameMapping(const std::string& name) const;
 
    virtual void InitialiseUser();
 
    virtual void SetCameraAddressUser(const std::string& address);
 
    virtual void CheckConnectionUser(bool& connected);
 
    virtual void CheckStatusUser(ccf::common::HwStatus& status,
                                 std::string& message);
 
    virtual bool HasCameraPropertyUser(const std::string& property,
                                       std::string& value);
 
    virtual double GetTheoreticFrameRateUser();
 
    virtual void ConnectUser();
 
    virtual void DisconnectUser();
 
    virtual bool IsConnectedUser() const;
 
    virtual void ReadUser(const std::string& name,
                          ctd::param::Parameter& par);
 
    virtual void ReadUser(const std::vector<std::string>& names,
                          std::vector<ctd::param::Parameter>& pars);
 
    virtual void ReceiveUser(ccf::common::DataFrame& frame,
                             bool& frame_received,
                             const double timeout,
                             bool& timed_out);
 
    virtual void ScanUser(std::vector<ctd::param::Parameter>& pars);
 
    virtual void StartUser();
 
    virtual void StopUser();
 
    virtual void WriteUser(const ctd::param::Parameter& par);
 
    virtual void WriteUser(const std::vector<ctd::param::Parameter>& pars);
 
    virtual void HandleSetupUser();
 
    virtual void HandleParPreWriteUser(ctd::param::Parameter& par);
 
    virtual void HandleParPostWriteUser(ctd::param::Parameter& par);
 
    virtual void HandleParPostReadUser(ctd::param::Parameter& par);
 
  protected:
    bool                              m_is_connected;
 
  private:
    bool                              m_initialised;
    bool                              m_is_sim_adapter;
    std::string                       m_protocol;
    std::string                       m_camera_address;
    std::string                       m_host_address;
    std::string                       m_id;
    bool                              m_allow_lost_frames;
    uint64_t                          m_lost_frames_count;
    NameMapping                       m_cam_name_mapping;
 
    std::map<std::string, ctd::param::Parameter> m_cam_property_registry;
  };
 
}
 
#endif // CCF_COMMON_COM_ADPT_BASE_HPP_H_