mtsPayload.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <string_view>
#include <nlohmann/json.hpp>
 
#include <optional>
#include <stdexcept>
#include <regex>
 
 
namespace pds::aqgc::devices {
    using nlohmann::json;
 
 
inline json get_untyped(const json& j, const char* property)
{
    auto it = j.find(property);
    if (it != j.end()) return *it;
    return json{};
}
 
inline json get_untyped(const json& j, const std::string& property)
{
    return get_untyped(j, property.c_str()); // C++17-safe
}
 
// Parse parameters that might be:
inline json parse_maybe_double_encoded(std::string_view s)
{
    json j = json::parse(s);
 
    if (j.is_string()) {
        const auto& inner = j.get_ref<const std::string&>();
        return json::parse(inner);
    }
    return j;
}
 
class MtsPayload
{
public:
    MtsPayload() = default;
    virtual ~MtsPayload() = default;
 
private:
    std::string action;
    std::string name;
    std::optional<double> pos = std::nullopt;
 
 
public:
    const std::string& GetAction() const { return action; }
    std::string& GetMutableAction() { return action; }
    void SetAction(const std::string& value) { action = value; }
 
    const std::string& GetName() const { return name; }
    std::string& GetMutableName() { return name; }
    void SetName(const std::string& value) { name = value; } 
 
    const double & GetPos() const { return pos.value(); }
    bool HasPos() const {return pos.has_value(); }
    double & GetMutablePos() { return pos.value(); }
    void SetPos(const double & value) { this->pos = value; }
 
};
 
inline void from_json(const json& j, MtsPayload& x)
{
    // Use value() for robustness; replace with at().get<>() if you want strict-throw.
    x.SetAction(j.value("action", ""));
    x.SetName  (j.value("name",   ""));
    if (j.count("pos") != 0)
        {
         x.SetPos(j.value("pos", 0));
        }
 
}
 
inline void to_json(json& j, const MtsPayload& x)
{
    j = json{
        {"action", x.GetAction()},
        {"name",   x.GetName()}
    };
 
     if (x.HasPos())
          {
            j["pos"] = x.GetPos();
          }
}
 
// Convenience: build payload directly from a "parameters" string
inline MtsPayload payload_from_parameters(std::string_view parameters)
{
    const json j = parse_maybe_double_encoded(parameters);
    return j.get<MtsPayload>(); 
}
 
}    
 
/*
namespace pds::aqgc::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 MtsPayload {
        public:
        MtsPayload() = default;
        virtual ~MtsPayload() = default;
 
        private:
        std::string action;
        std::string name;
       
 
        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 std::string & get_name() const { return name; }
        std::string & get_mutable_name() { return name; }
        void set_name(const std::string & value) { this->name = value; }
        
    };
}
 
namespace nlohmann {
    void from_json(const json & j, pds::aqgc::devices::MtsPayload & x);
    void to_json(json & j, const pds::aqgc::devices::MtsPayload & x);
 
    inline void from_json(const json & j, pds::aqgc::devices::MtsPayload& x) {
        x.set_action(j.at("action").get<std::string>());
        x.set_name(j.at("name").get<std::string>());
             
          
    }
 
    inline void to_json(json & j, const pds::aqgc::devices::MtsPayload & x) {
        j = json::object();
        j["action"] = x.get_action();
        j["name"] = x.get_name();
      
    }
}
*/