legacy_device.h

/*
 * Copyright 2021-present ifm electronic, gmbh
 * SPDX-License-Identifier: Apache-2.0
 */
 
#ifndef IFM3D_DEVICE_LEGACY_DEVICE_H
#define IFM3D_DEVICE_LEGACY_DEVICE_H
 
#include <ifm3d/device/device.h>
 
namespace ifm3d
{
  class IFM3D_EXPORT LegacyDevice : public Device
  {
  public:
    using Ptr = std::shared_ptr<LegacyDevice>;
 
    using boot_mode = ifm3d::Device::BootMode;
    using operating_mode = ifm3d::Device::OperatingMode;
    using trigger_mode = ifm3d::Device::TriggerMode;
    using import_flags = ifm3d::Device::ImportFlags;
    using spatial_filter = ifm3d::Device::SpatialFilter;
    using temporal_filter = ifm3d::Device::TemporalFilter;
    using mfilt_mask_size = ifm3d::Device::MedianfilterMaskSize;
    using device_family = ifm3d::Device::DeviceFamily;
 
    static Ptr MakeShared(
      const std::string& ip = ifm3d::DEFAULT_IP,
      std::uint16_t xmlrpc_port = ifm3d::DEFAULT_XMLRPC_PORT,
      const std::string& password = ifm3d::DEFAULT_PASSWORD);
 
    LegacyDevice(const std::string& ip = ifm3d::DEFAULT_IP,
                 std::uint16_t xmlrpc_port = ifm3d::DEFAULT_XMLRPC_PORT,
                 const std::string& password = ifm3d::DEFAULT_PASSWORD);
 
    LegacyDevice(const LegacyDevice&) = delete;
    LegacyDevice(LegacyDevice&&) = delete;
    LegacyDevice& operator=(const LegacyDevice&) = delete;
    LegacyDevice& operator=(LegacyDevice&&) = delete;
    ~LegacyDevice() override;
 
    virtual std::string Password();
 
    virtual std::string SessionID();
 
    virtual void FactoryReset();
 
    virtual std::string RequestSession();
 
    virtual bool CancelSession();
 
    virtual bool CancelSession(const std::string& sid);
 
    virtual int Heartbeat(int hb);
 
    virtual std::unordered_map<std::string, std::string> NetInfo();
    virtual std::unordered_map<std::string, std::string> TimeInfo();
 
    virtual void SetTemporaryApplicationParameters(
      const std::unordered_map<std::string, std::string>& params);
 
    virtual int ActiveApplication();
 
    virtual json ApplicationList();
 
    virtual std::vector<std::string> ApplicationTypes();
 
    virtual std::vector<std::string> ImagerTypes();
 
    virtual int CopyApplication(int idx);
 
    virtual int CreateApplication(
      const std::string& type = DEFAULT_APPLICATION_TYPE);
 
    virtual void DeleteApplication(int idx);
 
    virtual void SetCurrentTime(int epoch_secs = -1);
 
    virtual std::vector<std::uint8_t> UnitVectors();
 
    virtual std::vector<std::uint8_t> ExportIFMConfig();
 
    virtual std::vector<std::uint8_t> ExportIFMApp(int idx);
 
    virtual void ImportIFMConfig(const std::vector<std::uint8_t>& bytes,
                                 std::uint16_t flags = 0x0);
 
    virtual int ImportIFMApp(const std::vector<std::uint8_t>& bytes);
 
    virtual void SetPassword(const std::string& password = "");
 
    json ToJSON() override;
    void FromJSON(const json& j) override;
    void ForceTrigger() override;
 
  protected:
    class Impl;
    std::unique_ptr<Impl> _impl;
 
    void from_json(const json& j_curr,
                   const json& j_new,
                   const std::function<void(const std::string&,
                                            const std::string&)>& set_func,
                   const std::function<void()>& save_func,
                   const std::string& name,
                   int idx = -1);
 
    static bool get_app_json(int index, const json& j, json& app);
 
    json to_json(bool open_session = true);
 
    json get_application_infos_to_json();
 
    void apply_device_config(json& current, const json& root);
    void apply_apps_config(json& current, const json& root);
    void apply_time_config(json& current, const json& root);
    void apply_network_config(json& current, const json& root);
  };
}
 
#endif // IFM3D_DEVICE_LEGACY_DEVICE_H