lsmPayload.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "nlohmann/json.hpp"
 
#include <optional>
#include <stdexcept>
#include <regex>
 
namespace pds::maical::devices {
    using nlohmann::json;
 
    inline json get_untyped(const json & j, const char * property) {
        if (j.find(property) != j.end()) {
            return j.at(property).get<json>();
        }
        return json();
    }
 
    inline json get_untyped(const json & j, std::string property) {
        return get_untyped(j, property.data());
    }
 
    class LsmPayload {
        public:
        LsmPayload() = default;
        virtual ~LsmPayload() = default;
 
        private:
        std::string action;
        std::optional<double> ch_vis = std::nullopt;
        std::optional<double> ch_ir1 = std::nullopt;
        std::optional<double> ch_ir2 = std::nullopt;
        std::optional<int> on_duration = std::nullopt;
       
 
        public:
        const std::string & get_action() const { return action; }
        std::string & get_mutable_action() { return action; }
        void set_action(const std::string & value) { this->action = value; }
 
        const double & get_ch_vis() const { return ch_vis.value(); }
        bool has_ch_vis() const {return ch_vis.has_value(); }
        double & get_mutable_ch_vis() { return ch_vis.value(); }
        void set_ch_vis(const double & value) { this->ch_vis = value; }
        
        const double & get_ch_ir1() const { return ch_ir1.value(); }
        bool has_ch_ir1() const {return ch_ir1.has_value(); }
        double & get_mutable_ch_ir1() { return ch_ir1.value(); }
        void set_ch_ir1(const double & value) { this->ch_ir1 = value; }
        
        const double & get_ch_ir2() const { return ch_ir2.value(); }
        bool has_ch_ir2() const {return ch_ir2.has_value(); }
        double & get_mutable_ch_ir2() { return ch_ir2.value(); }
        void set_ch_ir2(const double & value) { this->ch_ir2 = value; }
        
        const int & get_on_duration() const { return on_duration.value(); }
        bool has_on_duration() const {return on_duration.has_value(); }
        int & get_mutable_on_duration() { return on_duration.value(); }
        void set_on_duration(const int & value) { this->on_duration = value; }
        
    };
}
 
namespace nlohmann {
    void from_json(const json & j, pds::maical::devices::LsmPayload & x);
    void to_json(json & j, const pds::maical::devices::LsmPayload & x);
 
    inline void from_json(const json & j, pds::maical::devices::LsmPayload& x) {
        x.set_action(j.at("action").get<std::string>());
             
        if (j.count("ch_vis") != 0) {
              x.set_ch_vis(j.at("ch_vis").get<double>());
        }
      
        if (j.count("ch_ir1") != 0) {
               x.set_ch_ir1(j.at("ch_ir1").get<double>());
        }
     
         if (j.count("ch_ir2") != 0) {
               x.set_ch_ir2(j.at("ch_ir2").get<double>());
         }
     
         if (j.count("time") != 0) {
               x.set_on_duration(j.at("time").get<int>());
         } 
          
    }
 
    inline void to_json(json & j, const pds::maical::devices::LsmPayload & x) {
        j = json::object();
        j["action"] = x.get_action();
      
        if (x.has_ch_vis())
          {
            j["ch_vis"] = x.get_ch_vis();
          }
        if (x.has_ch_ir1())
          {
            j["ch_ir1"] = x.get_ch_ir1();
          }  
        if (x.has_ch_ir2())
          {
            j["ch_ir2"] = x.get_ch_ir2();
          }  
        if (x.has_on_duration())
          {
            j["time"] = x.get_on_duration();
          }  
    }
}