device_model_storage_interface.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2023 Pionix GmbH and Contributors to EVerest
 
#pragma once
 
#include <map>
#include <memory>
#include <ocpp/common/support_older_cpp_versions.hpp>
#include <ocpp/v2/comparators.hpp>
#include <optional>
 
#include <ocpp/v2/enums.hpp>
#include <ocpp/v2/ocpp_types.hpp>
 
namespace ocpp {
namespace v2 {
 
struct VariableMonitoringMeta {
    VariableMonitoring monitor;
    VariableMonitorType type;
    std::optional<std::string> reference_value;
};
 
struct VariableMonitoringPeriodic {
    Component component;
    Variable variable;
    std::vector<VariableMonitoringMeta> monitors;
};
 
struct VariableMetaData {
    VariableCharacteristics characteristics;
    std::unordered_map<int64_t, VariableMonitoringMeta> monitors;
    std::optional<std::string> source;
};
 
using VariableMap = std::map<Variable, VariableMetaData>;
using DeviceModelMap = std::map<Component, VariableMap>;
 
class DeviceModelError : public std::exception {
public:
    [[nodiscard]] const char* what() const noexcept override {
        return this->reason.c_str();
    }
    explicit DeviceModelError(std::string msg) {
        this->reason = std::move(msg);
    }
    explicit DeviceModelError(const char* msg) {
        this->reason = std::string(msg);
    }
 
private:
    std::string reason;
};
 
class DeviceModelStorageInterface {
 
public:
    virtual ~DeviceModelStorageInterface() = default;
 
    virtual DeviceModelMap get_device_model() = 0;
 
    virtual std::optional<VariableAttribute> get_variable_attribute(const Component& component_id,
                                                                    const Variable& variable_id,
                                                                    const AttributeEnum& attribute_enum) = 0;
    virtual std::vector<VariableAttribute>
    get_variable_attributes(const Component& component_id, const Variable& variable_id,
                            const std::optional<AttributeEnum>& attribute_enum = std::nullopt) = 0;
 
    virtual bool set_variable_attribute_value(const Component& component_id, const Variable& variable_id,
                                              const AttributeEnum& attribute_enum, const std::string& value,
                                              const std::string& source) = 0;
 
    virtual std::optional<VariableMonitoringMeta> set_monitoring_data(const SetMonitoringData& data,
                                                                      const VariableMonitorType type) = 0;
 
    virtual bool update_monitoring_reference(const int32_t monitor_id, const std::string& reference_value) = 0;
 
    virtual std::vector<VariableMonitoringMeta>
    get_monitoring_data(const std::vector<MonitoringCriterionEnum>& criteria, const Component& component_id,
                        const Variable& variable_id) = 0;
 
    virtual ClearMonitoringStatusEnum clear_variable_monitor(int monitor_id, bool allow_protected) = 0;
 
    virtual int32_t clear_custom_variable_monitors() = 0;
 
    virtual void check_integrity() = 0;
};
 
} // namespace v2
} // namespace ocpp