dd_validationinfomodel.h

Go to the documentation of this file.

 
#ifndef DD_VALIDATIONINFOMODEL_H_INCLUDED
#define DD_VALIDATIONINFOMODEL_H_INCLUDED
 
#include <a_util/preprocessor/deprecated.h> // DEV_ESSENTIAL_DEPRECATED()
#include <ddl/datamodel/datamodel_datadefinition.h>
#include <ddl/dd/dd_error.h>
#include <ddl/dd/dd_infomodel_type.h>
 
#include <map>
#include <memory>
#include <unordered_map>
#include <unordered_set>
 
#define DEV_ESSENTIAL_DEPRECATED_VALIDATION_API                                                    \
    DEV_ESSENTIAL_DEPRECATED("Use the ddl::dd::DataDefinition::isValid() and "                     \
                             "ddl::dd::DataDefinition::getValidationProtocol() instead.")
 
namespace ddl {
 
namespace dd {
class ValidationServiceInfo : public datamodel::Info<ValidationServiceInfo> {
public:
    static constexpr const uint8_t INFO_TYPE_ID = dd::InfoType::validation_service_info;
 
    enum DependencyType : uint8_t {
        unit_to_unit_prefix,
        unit_to_base_unit,
        data_type_to_unit,
        data_type_to_base_unit,
        enum_type_to_data_type,
        struct_type_to_data_type,
        struct_type_to_enum_type,
        struct_type_to_struct_type,
        struct_type_to_unit,
        struct_type_to_base_unit,
        stream_meta_type_to_stream_meta_type,
        stream_to_stream_meta_type,
        stream_to_struct_type
    };
 
    DEV_ESSENTIAL_DEPRECATED_VALIDATION_API
    ValidationServiceInfo() = default;
 
    struct Dependency {
    public:
        Dependency() = delete;
        Dependency(DependencyType type_of_dependency,
                   const std::string& from,
                   const std::string& to);
        ~Dependency() = default;
 
        DependencyType _type_of_dependency;
        std::string _from;
        std::string _to;
    };
 
    void addDependency(const Dependency& dependency);
    void removed(const datamodel::BaseUnit& base_unit, datamodel::DataDefinition& parent_dd);
    void removed(const datamodel::UnitPrefix& unit_prefix, datamodel::DataDefinition& parent_dd);
    void removed(const datamodel::Unit& unit, datamodel::DataDefinition& parent_dd);
    void removed(const datamodel::DataType& data_type, datamodel::DataDefinition& parent_dd);
    void removed(const datamodel::EnumType& enum_type, datamodel::DataDefinition& parent_dd);
    void removed(const datamodel::StructType& struct_type, datamodel::DataDefinition& parent_dd);
    void removed(const datamodel::StreamMetaType& stream_meta_type,
                 datamodel::DataDefinition& parent_dd);
    void removed(const datamodel::Stream& stream, datamodel::DataDefinition& parent_dd);
 
    void renamed(const datamodel::BaseUnit& base_unit,
                 const std::string& old_name,
                 datamodel::DataDefinition& parent_dd);
    void renamed(const datamodel::UnitPrefix& unit_prefix,
                 const std::string& old_name,
                 datamodel::DataDefinition& parent_dd);
    void renamed(const datamodel::Unit& unit,
                 const std::string& old_name,
                 datamodel::DataDefinition& parent_dd);
    void renamed(const datamodel::DataType& data_type,
                 const std::string& old_name,
                 datamodel::DataDefinition& parent_dd);
    void renamed(const datamodel::EnumType& enum_type,
                 const std::string& old_name,
                 datamodel::DataDefinition& parent_dd);
    void renamed(const datamodel::StructType& struct_type,
                 const std::string& old_name,
                 datamodel::DataDefinition& parent_dd);
    void renamed(const datamodel::StreamMetaType& stream_meta_type,
                 const std::string& old_name,
                 datamodel::DataDefinition& parent_dd);
    void renamed(const datamodel::Stream& stream,
                 const std::string& old_name,
                 datamodel::DataDefinition& parent_dd);
 
    bool validationNeeded() const;
    typedef std::unordered_map<std::string, std::unordered_set<std::string>> ToFromMap;
 
    struct InvalidatedTypes {
        std::vector<std::string> _enum_type_names;
        std::vector<std::string> _struct_type_names;
    };
    void forceRevalidationOfTypeDependencies(const std::string& type_name,
                                             ddl::dd::TypeOfType type,
                                             datamodel::DataDefinition& parent_dd,
                                             InvalidatedTypes& invalidated_types_to_return) const;
    using ValidationProblemId = void*;
    class ValidationProblem {
    public:
        ValidationProblem() = default;
        ValidationProblem(ValidationLevel level, const ddl::dd::Problem& problem);
        ValidationProblem(const ddl::dd::Problem& problem);
        ValidationLevel getLevel() const;
        ddl::dd::Problem getProblem() const;
 
    private:
        ValidationLevel _level = ValidationLevel::valid;
        ddl::dd::Problem _problem = {};
    };
 
    void updateProblem(ValidationProblemId id,
                       const std::shared_ptr<const ValidationProblem>& problem);
    void removeProblem(ValidationProblemId id, ValidationLevel level);
    ValidationLevel getValidationLevel() const;
    std::vector<Problem> getProblems() const;
 
private:
#if defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wattributes"
#endif // defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
 
    std::unordered_map<uint8_t, ToFromMap> _dependencies;
    std::map<uint8_t,
             std::unordered_map<ValidationProblemId, std::shared_ptr<const ValidationProblem>>>
        _validation_problems;
 
#if defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
#pragma GCC diagnostic pop
#endif // defined(__GNUC__) && ((__GNUC__ == 5) && (__GNUC_MINOR__ == 2))
 
    bool _validation_needed = true;
};
 
class ValidationInfo : public datamodel::Info<ValidationInfo> {
public:
    static constexpr const uint8_t INFO_TYPE_ID = dd::InfoType::validation_info;
 
    DEV_ESSENTIAL_DEPRECATED_VALIDATION_API
    ValidationInfo() = default;
    DEV_ESSENTIAL_DEPRECATED_VALIDATION_API
    ValidationInfo(datamodel::Unit& unit, datamodel::DataDefinition& parent_dd);
    DEV_ESSENTIAL_DEPRECATED_VALIDATION_API
    ValidationInfo(datamodel::DataType& data_type, datamodel::DataDefinition& parent_dd);
    DEV_ESSENTIAL_DEPRECATED_VALIDATION_API
    ValidationInfo(datamodel::EnumType& enum_type, datamodel::DataDefinition& parent_dd);
    DEV_ESSENTIAL_DEPRECATED_VALIDATION_API
    ValidationInfo(datamodel::Stream& stream, datamodel::DataDefinition& parent_dd);
    virtual ~ValidationInfo();
 
    enum ValidationLevel : uint8_t {
        dont_know,
        invalid,
        good_enough,
        valid
    };
 
    using Problem = ddl::dd::Problem;
 
    bool isValid(ValidationLevel level = ValidationLevel::valid) const;
 
    void forceRevalidation();
    ValidationLevel getValidationLevel() const;
 
    std::vector<Problem> getProblems() const;
    void addProblem(ValidationServiceInfo::ValidationProblem&& problem);
    void addProblem(const ValidationServiceInfo::ValidationProblem& problem);
 
    void removeProblems(datamodel::DataDefinition& parent_dd);
 
    void update(datamodel::Unit& unit, datamodel::DataDefinition& parent_dd);
    void update(datamodel::DataType& data_type, datamodel::DataDefinition& parent_dd);
    void update(datamodel::EnumType& enum_type, datamodel::DataDefinition& parent_dd);
    enum class UpdateType {
        all = 0,      
        only_last = 1 
    };
    void update(datamodel::StructType& struct_type,
                datamodel::DataDefinition& parent_dd,
                UpdateType update_type = UpdateType::all);
    void update(datamodel::StreamMetaType& stream_meta_type, datamodel::DataDefinition& parent_dd);
    void update(datamodel::Stream& stream, datamodel::DataDefinition& parent_dd);
 
private:
    bool _currently_on_validation = false; // to prevent recursive validation calls if somebody
                                           // defines this type as a part of the type
    void addProblem(const std::shared_ptr<ValidationServiceInfo::ValidationProblem>& problem);
    std::map<uint8_t,
             std::unordered_map<ValidationServiceInfo::ValidationProblemId,
                                std::shared_ptr<ValidationServiceInfo::ValidationProblem>>>
        _validation_problems;
    ValidationServiceInfo* _current_validation_service = {};
    bool _is_validated = false;
};
 
} // namespace dd
} // namespace ddl
 
#endif // DD_VALIDATIONINFOMODEL_H_INCLUDED