json_conversions.cpp

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    VisionX::ArmarXObjects::armem_images_server
 * @author     Rainer Kartmann ( rainer dot kartmann at kit dot edu )
 * @date       2021
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#include "json_conversions.h"
 
#include <SimoxUtility/algorithm/string/string_tools.h>
#include <SimoxUtility/color/Color.h>
#include <SimoxUtility/color/json.h>
#include <SimoxUtility/json/util.h>
 
#include <ArmarXCore/core/logging/Logging.h>
#include <ArmarXCore/core/time/DateTime.h>
#include <ArmarXCore/core/time/ice_conversions.h>
#include <ArmarXCore/core/time/json_conversions.h>
 
#include <RobotAPI/libraries/aron/common/aron_conversions/simox.h>
#include <RobotAPI/libraries/aron/common/json_conversions.h>
#include <RobotAPI/libraries/aron/converter/json/NLohmannJSONConverter.h>
 
#include <VisionX/libraries/armem_human/aron/Person.aron.generated.h>
 
namespace armarx::human
{
 
    template <class ValueType>
    std::optional<ValueType>
    opt_from_json(const simox::json::json& j, const std::string key)
    {
        if (j.count(key))
        {
            ValueType value;
            j.at(key).get_to(value);
            return std::optional(value);
        }
        return std::nullopt;
    }
 
    template <class ValueType>
    void
    set_if_present(simox::json::json& j,
                   const std::string key,
                   const std::optional<ValueType> optional)
    {
        if (optional.has_value())
        {
            j[key] = optional.value();
        }
    }
 
    void
    arondto::to_json(simox::json::json& j, const Person& arondto)
    {
        j["firstName"] = arondto.id.firstName;
        j["lastName"] = arondto.id.lastName;
        j["names"] = arondto.names;
 
        j["roles"] = arondto.roles;
 
        if (arondto.attributes)
        {
            j["attributes"] = aron::converter::AronNlohmannJSONConverter::ConvertToNlohmannJSON(
                arondto.attributes);
        }
        else
        {
            j["attributes"] = simox::json::json::object();
        }
 
        set_if_present(j, "rooms", arondto.rooms);
        j["physiologicalBiometrics"] = arondto.physiologicalBiometrics;
        j["previousInteractions"] = arondto.previousInteractions;
        j["preferences"] = arondto.preferences;
        j["abilities"] = arondto.abilities;
        j["medicalConditions"] = arondto.medicalConditions;
        j["customAttributes"] = arondto.customAttributes;
        j["customNotes"] = arondto.customNotes;
    }
 
    void
    arondto::from_json(const simox::json::json& j, Person& arondto)
    {
        using namespace simox::json;
 
        ARMARX_INFO << "Converting profile from json to profile";
 
        get_to_if_exists(j, "firstName", arondto.id.firstName);
        get_to_if_exists(j, "lastName", arondto.id.lastName);
 
        get_to_if_exists(j, "names", arondto.names);
 
        get_to_if_exists(j, "roles", arondto.roles);
 
        if (j.count("attributes"))
        {
            aron::data::VariantPtr data = nullptr;
            aron::converter::AronNlohmannJSONConverter::ConvertFromNlohmannJSON(data,
                                                                                j.at("attributes"));
            if (auto dict = std::dynamic_pointer_cast<aron::data::Dict>(data))
            {
                arondto.attributes = dict;
            }
            else
            {
                arondto.attributes = nullptr;
            }
        }
        else
        {
            arondto.attributes = nullptr;
        }
 
        arondto.rooms = opt_from_json<PersonalRooms>(j, "rooms");
        get_to_if_exists(j, "physiologicalBiometrics", arondto.physiologicalBiometrics);
        get_to_if_exists(j, "previousInteractions", arondto.previousInteractions);
        get_to_if_exists(j, "preferences", arondto.preferences);
        get_to_if_exists(j, "abilities", arondto.abilities);
        get_to_if_exists(j, "medicalConditions", arondto.medicalConditions);
        get_to_if_exists(j, "customAttributes", arondto.customAttributes);
        get_to_if_exists(j, "customNotes", arondto.customNotes);
    }
 
    void
    arondto::to_json(simox::json::json& j, const Gender& arondto)
    {
        j = simox::alg::to_lower(arondto.toString());
    }
 
    void
    arondto::from_json(const simox::json::json& j, Gender& arondto)
    {
        arondto.fromString(simox::alg::to_upper(j.get<std::string>()));
    }
 
    void
    arondto::to_json(simox::json::json& j, const Handedness& arondto)
    {
        j = simox::alg::to_lower(arondto.toString());
    }
 
    void
    arondto::from_json(const simox::json::json& j, Handedness& arondto)
    {
        arondto.fromString(simox::alg::to_upper(j.get<std::string>()));
    }
 
    void
    arondto::to_json(simox::json::json& j, const PhysicalData& arondto)
    {
        j["gender"] = arondto.gender;
        j["handedness"] = arondto.handedness;
        set_if_present(j, "birthday", arondto.birthday);
        set_if_present(j, "heightInMillimeters", arondto.heightInMillimeters);
        set_if_present(j, "weightInGrams", arondto.weightInGrams);
    }
 
    void
    arondto::from_json(const simox::json::json& j, PhysicalData& arondto)
    {
        using namespace simox::json;
 
        get_to_if_exists(j, "gender", arondto.gender, Gender::DIVERSE);
        get_to_if_exists(j, "handedness", arondto.handedness, Handedness::BOTH);
 
        arondto.birthday = opt_from_json<DateTime>(j, "birthday");
        arondto.heightInMillimeters = opt_from_json<float>(j, "heightInMillimeters");
        arondto.weightInGrams = opt_from_json<float>(j, "weightInGrams");
    }
 
    void
    arondto::to_json(simox::json::json& j, const Abilities& arondto)
    {
        set_if_present(j, "canGraspLeft", arondto.canGraspLeft);
        set_if_present(j, "canGraspRight", arondto.canGraspRight);
        set_if_present(j, "canStand", arondto.canStand);
        set_if_present(j, "canWalk", arondto.canWalk);
        set_if_present(j, "isBlind", arondto.isBlind);
        set_if_present(j, "isColorblind", arondto.isColorblind);
        set_if_present(j, "isDeaf", arondto.isDeaf);
    }
 
    void
    arondto::from_json(const simox::json::json& j, Abilities& arondto)
    {
        arondto.canGraspLeft = opt_from_json<bool>(j, "canGraspLeft");
        arondto.canGraspRight = opt_from_json<bool>(j, "canGraspRight");
        arondto.canStand = opt_from_json<bool>(j, "canStand");
        arondto.canWalk = opt_from_json<bool>(j, "canWalk");
        arondto.isBlind = opt_from_json<bool>(j, "isBlind");
        arondto.isColorblind = opt_from_json<bool>(j, "isColorblind");
        arondto.isDeaf = opt_from_json<bool>(j, "isDeaf");
    }
 
    void
    arondto::to_json(simox::json::json& j, const Preference& arondto)
    {
        j["preferred"] = arondto.preferred;
        j["disliked"] = arondto.disliked;
    }
 
    void
    arondto::from_json(const simox::json::json& j, Preference& arondto)
    {
        using namespace simox::json;
        get_to_if_exists(j, "preferred", arondto.preferred);
        get_to_if_exists(j, "disliked", arondto.disliked);
    }
 
    void
    arondto::to_json(simox::json::json& j, const Preferences& arondto)
    {
        set_if_present(j, "communicationStyle", arondto.communicationStyle);
        set_if_present(j, "color", arondto.color);
        set_if_present(j, "drink", arondto.drink);
        set_if_present(j, "food", arondto.food);
        set_if_present(j, "hobbies", arondto.hobbies);
        set_if_present(j, "music", arondto.music);
        set_if_present(j, "fashion", arondto.fashion);
        set_if_present(j, "travel", arondto.travel);
        set_if_present(j, "people", arondto.people);
        set_if_present(j, "work", arondto.work);
        set_if_present(j, "technology", arondto.technology);
        set_if_present(j, "valuesAndBeliefs", arondto.valuesAndBeliefs);
    }
 
    void
    arondto::from_json(const simox::json::json& j, Preferences& arondto)
    {
        arondto.communicationStyle = opt_from_json<Preference>(j, "communicationStyle");
        arondto.color = opt_from_json<Preference>(j, "color");
        arondto.drink = opt_from_json<Preference>(j, "drink");
        arondto.food = opt_from_json<Preference>(j, "food");
        arondto.hobbies = opt_from_json<Preference>(j, "hobbies");
        arondto.music = opt_from_json<Preference>(j, "music");
        arondto.fashion = opt_from_json<Preference>(j, "fashion");
        arondto.travel = opt_from_json<Preference>(j, "travel");
        arondto.people = opt_from_json<Preference>(j, "people");
        arondto.work = opt_from_json<Preference>(j, "work");
        arondto.technology = opt_from_json<Preference>(j, "technology");
        arondto.valuesAndBeliefs = opt_from_json<Preference>(j, "valuesAndBeliefs");
    }
 
    void
    arondto::to_json(simox::json::json& j, const PersonalRooms& arondto)
    {
        j["bedroom"] = arondto.bedroom;
    }
 
    void
    arondto::from_json(const simox::json::json& j, PersonalRooms& arondto)
    {
        simox::json::get_to_if_exists(j, "bedroom", arondto.bedroom);
    }
 
} // namespace armarx::human