device_model.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
 
#ifndef DEVICE_MODEL_HPP
#define DEVICE_MODEL_HPP
 
#include <type_traits>
 
#include <everest/logging.hpp>
 
#include <ocpp/v2/device_model_storage_interface.hpp>
 
namespace ocpp {
namespace v2 {
 
template <typename T> struct RequestDeviceModelResponse {
    GetVariableStatusEnum status;
    std::optional<T> value;
};
 
template <typename T> T to_specific_type(const std::string& value) {
    static_assert(std::is_same<T, std::string>::value || std::is_same<T, int>::value ||
                      std::is_same<T, double>::value || std::is_same<T, size_t>::value ||
                      std::is_same<T, DateTime>::value || std::is_same<T, bool>::value ||
                      std::is_same<T, uint64_t>::value,
                  "Requested unknown datatype");
 
    if constexpr (std::is_same<T, std::string>::value) {
        return value;
    } else if constexpr (std::is_same<T, int>::value) {
        return std::stoi(value);
    } else if constexpr (std::is_same<T, double>::value) {
        return std::stod(value);
    } else if constexpr (std::is_same<T, size_t>::value) {
        size_t res = std::stoul(value);
        return res;
    } else if constexpr (std::is_same<T, DateTime>::value) {
        return DateTime(value);
    } else if constexpr (std::is_same<T, bool>::value) {
        return ocpp::conversions::string_to_bool(value);
    } else if constexpr (std::is_same<T, uint64_t>::value) {
        return std::stoull(value);
    }
}
 
template <DataEnum T> auto to_specific_type_auto(const std::string& value) {
    static_assert(T == DataEnum::string || T == DataEnum::integer || T == DataEnum::decimal ||
                      T == DataEnum::dateTime || T == DataEnum::boolean,
                  "Requested unknown datatype");
 
    if constexpr (T == DataEnum::string) {
        return to_specific_type<std::string>(value);
    } else if constexpr (T == DataEnum::integer) {
        return to_specific_type<int>(value);
    } else if constexpr (T == DataEnum::decimal) {
        return to_specific_type<double>(value);
    } else if constexpr (T == DataEnum::dateTime) {
        return to_specific_type<DateTime>(value);
    } else if constexpr (T == DataEnum::boolean) {
        return to_specific_type<bool>(value);
    }
}
 
template <DataEnum T> bool is_type_numeric() {
    static_assert(T == DataEnum::string || T == DataEnum::integer || T == DataEnum::decimal ||
                      T == DataEnum::dateTime || T == DataEnum::boolean || T == DataEnum::OptionList ||
                      T == DataEnum::SequenceList || T == DataEnum::MemberList,
                  "Requested unknown datatype");
 
    if constexpr (T == DataEnum::integer || T == DataEnum::decimal) {
        return true;
    } else {
        return false;
    }
}
 
typedef std::function<void(const std::unordered_map<int64_t, VariableMonitoringMeta>& monitors,
                           const Component& component, const Variable& variable,
                           const VariableCharacteristics& characteristics, const VariableAttribute& attribute,
                           const std::string& value_previous, const std::string& value_current)>
    on_variable_changed;
 
typedef std::function<void(const VariableMonitoringMeta& updated_monitor, const Component& component,
                           const Variable& variable, const VariableCharacteristics& characteristics,
                           const VariableAttribute& attribute, const std::string& current_value)>
    on_monitor_updated;
 
class DeviceModel {
 
private:
    DeviceModelMap device_model_map;
    std::unique_ptr<DeviceModelStorageInterface> device_model;
 
    on_variable_changed variable_listener;
    on_monitor_updated monitor_update_listener;
 
    GetVariableStatusEnum request_value_internal(const Component& component_id, const Variable& variable_id,
                                                 const AttributeEnum& attribute_enum, std::string& value,
                                                 bool allow_write_only) const;
 
    bool component_criteria_match(const Component& component_id,
                                  const std::vector<ComponentCriterionEnum>& component_criteria);
 
    bool component_variables_match(const std::vector<ComponentVariable>& component_variables,
                                   const ocpp::v2::Component& component_, const struct ocpp::v2::Variable& variable_);
 
public:
    explicit DeviceModel(std::unique_ptr<DeviceModelStorageInterface> device_model_storage_interface);
 
    template <typename T>
    T get_value(const RequiredComponentVariable& component_variable,
                const AttributeEnum& attribute_enum = AttributeEnum::Actual) const {
        std::string value;
        auto response = GetVariableStatusEnum::UnknownVariable;
        if (component_variable.variable.has_value()) {
            response = this->request_value_internal(component_variable.component, component_variable.variable.value(),
                                                    attribute_enum, value, true);
        }
        if (response == GetVariableStatusEnum::Accepted) {
            return to_specific_type<T>(value);
        } else {
            EVLOG_critical << "Directly requested value for ComponentVariable that doesn't exist in the device model: "
                           << component_variable;
            EVLOG_AND_THROW(std::runtime_error(
                "Directly requested value for ComponentVariable that doesn't exist in the device model."));
        }
    }
 
    template <typename T>
    std::optional<T> get_optional_value(const ComponentVariable& component_variable,
                                        const AttributeEnum& attribute_enum = AttributeEnum::Actual) const {
        std::string value;
        auto response = GetVariableStatusEnum::UnknownVariable;
        if (component_variable.variable.has_value()) {
            response = this->request_value_internal(component_variable.component, component_variable.variable.value(),
                                                    attribute_enum, value, true);
        }
        if (response == GetVariableStatusEnum::Accepted) {
            return to_specific_type<T>(value);
        } else {
            return std::nullopt;
        }
    }
 
    template <typename T>
    RequestDeviceModelResponse<T> request_value(const Component& component_id, const Variable& variable_id,
                                                const AttributeEnum& attribute_enum) {
        std::string value;
        const auto req_status = this->request_value_internal(component_id, variable_id, attribute_enum, value, false);
 
        if (req_status == GetVariableStatusEnum::Accepted) {
            return {GetVariableStatusEnum::Accepted, to_specific_type<T>(value)};
        } else {
            return {req_status};
        }
    }
 
    std::optional<MutabilityEnum> get_mutability(const Component& component_id, const Variable& variable,
                                                 const AttributeEnum& attribute_enum);
 
    SetVariableStatusEnum set_value(const Component& component_id, const Variable& variable_id,
                                    const AttributeEnum& attribute_enum, const std::string& value,
                                    const std::string& source, const bool allow_read_only = false);
    SetVariableStatusEnum set_read_only_value(const Component& component_id, const Variable& variable_id,
                                              const AttributeEnum& attribute_enum, const std::string& value,
                                              const std::string& source);
 
    std::optional<VariableMetaData> get_variable_meta_data(const Component& component_id, const Variable& variable_id);
 
    std::vector<ReportData> get_base_report_data(const ReportBaseEnum& report_base);
 
    std::vector<ReportData>
    get_custom_report_data(const std::optional<std::vector<ComponentVariable>>& component_variables = std::nullopt,
                           const std::optional<std::vector<ComponentCriterionEnum>>& component_criteria = std::nullopt);
 
    void register_variable_listener(on_variable_changed&& listener) {
        variable_listener = std::move(listener);
    }
 
    void register_monitor_listener(on_monitor_updated&& listener) {
        monitor_update_listener = std::move(listener);
    }
 
    std::vector<SetMonitoringResult> set_monitors(const std::vector<SetMonitoringData>& requests,
                                                  const VariableMonitorType type = VariableMonitorType::CustomMonitor);
 
    bool update_monitor_reference(int32_t monitor_id, const std::string& reference_value);
 
    std::vector<VariableMonitoringPeriodic> get_periodic_monitors();
 
    std::vector<MonitoringData> get_monitors(const std::vector<MonitoringCriterionEnum>& criteria,
                                             const std::vector<ComponentVariable>& component_variables);
 
    std::vector<ClearMonitoringResult> clear_monitors(const std::vector<int>& request_ids,
                                                      bool allow_protected = false);
 
    int32_t clear_custom_monitors();
 
    void check_integrity(const std::map<int32_t, int32_t>& evse_connector_structure);
};
 
} // namespace v2
} // namespace ocpp
 
#endif // DEVICE_MODEL_HPP