verification.hpp

Go to the documentation of this file.

#ifndef AAS_CORE_AAS_3_1_VERIFICATION_GUARD_
#define AAS_CORE_AAS_3_1_VERIFICATION_GUARD_
 
// This code has been automatically generated by aas-core-codegen.
// Do NOT edit or append.
 
#include "aas_core/aas_3_1/common.hpp"
#include "aas_core/aas_3_1/iteration.hpp"
#include "aas_core/aas_3_1/pattern.hpp"
#include "aas_core/aas_3_1/types.hpp"
 
#pragma warning(push, 0)
#include <set>
#pragma warning(pop)
 
namespace aas_core {
namespace aas_3_1 {
 
namespace verification {
 
// region Forward declarations
class Iterator;
class IVerification;
 
namespace impl {
class IVerificator;
}  // namespace impl
// endregion Forward declarations
 
struct Error {
  std::wstring cause;
 
  iteration::Path path;
 
  explicit Error(std::wstring a_cause);
  Error(std::wstring a_cause, iteration::Path a_path);
};  // struct Error
 
class Iterator {
  using iterator_category = std::forward_iterator_tag;
  using difference_type = std::ptrdiff_t;
  using value_type = Error;
  using pointer = const Error*;
  using reference = const Error&;
 
 public:
  explicit Iterator(
    std::unique_ptr<impl::IVerificator> verificator
  ) :
  verificator_(std::move(verificator)) {
      // Intentionally empty.
  }
 
  Iterator(const Iterator& other);
  Iterator(Iterator&& other);
 
  Iterator& operator=(const Iterator& other);
  Iterator& operator=(Iterator&& other);
 
  reference operator*() const;
  pointer operator->() const;
 
  // Prefix increment
  Iterator& operator++();
 
  // Postfix increment
  Iterator operator++(int);
 
  friend bool operator==(const Iterator& a, const Iterator& b);
  friend bool operator!=(const Iterator& a, const Iterator& b);
 
 private:
  std::unique_ptr<impl::IVerificator> verificator_;
};
 
bool operator==(const Iterator& a, const Iterator& b);
 
bool operator!=(const Iterator& a, const Iterator& b);
 
namespace impl {
class IVerificator {
 public:
  virtual void Start() = 0;
  virtual void Next() = 0;
  virtual bool Done() const = 0;
 
  virtual const Error& Get() const = 0;
  virtual Error& GetMutable() = 0;
  virtual long Index() const = 0;
 
  virtual std::unique_ptr<IVerificator> Clone() const = 0;
 
  virtual ~IVerificator() = default;
};  // class IVerificator
}  // namespace impl
 
class IVerification {
 public:
  virtual Iterator begin() const = 0;
  virtual const Iterator& end() const = 0;
  virtual ~IVerification() = default;
};  // class IVerification
 
class NonRecursiveVerification : public IVerification {
 public:
  NonRecursiveVerification(
    const std::shared_ptr<types::IClass>& instance
  );
 
  Iterator begin() const override;
  const Iterator& end() const override;
 
  ~NonRecursiveVerification() override = default;
 private:
  const std::shared_ptr<types::IClass>& instance_;
};  // class NonRecursiveVerification
 
class RecursiveVerification : public IVerification {
 public:
  RecursiveVerification(
    const std::shared_ptr<types::IClass>& instance
  );
 
  Iterator begin() const override;
  const Iterator& end() const override;
 
  ~RecursiveVerification() override = default;
 private:
  const std::shared_ptr<types::IClass>& instance_;
};  // class RecursiveVerification
 
// region Verification functions
 
bool MatchesIdShort(
  const std::wstring& text
);
 
bool MatchesVersionType(
  const std::wstring& text
);
 
bool MatchesRevisionType(
  const std::wstring& text
);
 
bool MatchesXsDateTimeUtc(
  const std::wstring& text
);
 
bool IsXsDateTimeUtc(
  const std::wstring& text
);
 
bool MatchesMimeType(
  const std::wstring& text
);
 
bool MatchesRfc2396(
  const std::wstring& text
);
 
bool MatchesBcp47(
  const std::wstring& text
);
 
template<
  typename LangStringT,
  typename std::enable_if<
    std::is_base_of<types::IAbstractLangString, LangStringT>::value
  >::type* = nullptr
>
bool LangStringsHaveUniqueLanguages(
  const std::vector<
    std::shared_ptr<LangStringT>
  >& lang_strings
) {
  // NOTE (mristin):
  // See: https://stackoverflow.com/questions/1349734/why-would-anyone-use-set-instead-of-unordered-set
  // For small sets, std::set is often faster than std::unordered_set.
  std::set<std::wstring> language_set;
 
  for (const std::shared_ptr<LangStringT>& lang_string : lang_strings) {
    const std::wstring& language = lang_string->language();
 
    if (language_set.find(language) != language_set.end()) {
      return false;
    }
    language_set.insert(language);
  }
 
  return true;
}
 
bool QualifierTypesAreUnique(
  const std::vector<
    std::shared_ptr<types::IQualifier>
  >& qualifiers
);
 
bool MatchesXmlSerializableString(
  const std::wstring& text
);
 
bool MatchesXsAnyUri(
  const std::wstring& text
);
 
bool MatchesXsBase64Binary(
  const std::wstring& text
);
 
bool MatchesXsBoolean(
  const std::wstring& text
);
 
bool MatchesXsDate(
  const std::wstring& text
);
 
bool MatchesXsDateTime(
  const std::wstring& text
);
 
bool IsXsDateTime(
  const std::wstring& text
);
 
bool MatchesXsDecimal(
  const std::wstring& text
);
 
bool MatchesXsDouble(
  const std::wstring& text
);
 
bool MatchesXsDuration(
  const std::wstring& text
);
 
bool MatchesXsFloat(
  const std::wstring& text
);
 
bool MatchesXsGDay(
  const std::wstring& text
);
 
bool MatchesXsGMonth(
  const std::wstring& text
);
 
bool MatchesXsGMonthDay(
  const std::wstring& text
);
 
bool MatchesXsGYear(
  const std::wstring& text
);
 
bool MatchesXsGYearMonth(
  const std::wstring& text
);
 
bool MatchesXsHexBinary(
  const std::wstring& text
);
 
bool MatchesXsTime(
  const std::wstring& text
);
 
bool MatchesXsInteger(
  const std::wstring& text
);
 
bool MatchesXsLong(
  const std::wstring& text
);
 
bool MatchesXsInt(
  const std::wstring& text
);
 
bool MatchesXsShort(
  const std::wstring& text
);
 
bool MatchesXsByte(
  const std::wstring& text
);
 
bool MatchesXsNonNegativeInteger(
  const std::wstring& text
);
 
bool MatchesXsPositiveInteger(
  const std::wstring& text
);
 
bool MatchesXsUnsignedLong(
  const std::wstring& text
);
 
bool MatchesXsUnsignedInt(
  const std::wstring& text
);
 
bool MatchesXsUnsignedShort(
  const std::wstring& text
);
 
bool MatchesXsUnsignedByte(
  const std::wstring& text
);
 
bool MatchesXsNonPositiveInteger(
  const std::wstring& text
);
 
bool MatchesXsNegativeInteger(
  const std::wstring& text
);
 
bool MatchesXsString(
  const std::wstring& text
);
 
bool ValueConsistentWithXsdType(
  const std::wstring& value,
  types::DataTypeDefXsd value_type
);
 
bool IsXsDate(const std::wstring& text);
 
bool IsXsDouble(const std::wstring& value);
 
bool IsXsFloat(const std::wstring& value);
 
bool IsXsGMonthDay(const std::wstring& value);
 
bool IsXsLong(const std::wstring& value);
 
bool IsXsInt(const std::wstring& value);
 
bool IsXsShort(const std::wstring& value);
 
bool IsXsByte(const std::wstring& value);
 
bool IsXsUnsignedLong(const std::wstring& value);
 
bool IsXsUnsignedInt(const std::wstring& value);
 
bool IsXsUnsignedShort(const std::wstring& value);
 
bool IsXsUnsignedByte(const std::wstring& value);
 
bool IsModelReferenceTo(
  const std::shared_ptr<types::IReference>& reference,
  types::KeyTypes expected_type
);
 
bool IsModelReferenceToReferable(
  const std::shared_ptr<types::IReference>& reference
);
 
template<
  typename ReferableT,
  typename std::enable_if<
    std::is_base_of<types::IReferable, ReferableT>::value
  >::type* = nullptr
>bool IdShortsAreUnique(
  const std::vector<
    std::shared_ptr<ReferableT>
  >& referables
) {
  std::set<std::wstring> id_short_set;
 
  for (const std::shared_ptr<types::IReferable> referable : referables) {
    const common::optional<std::wstring>& id_short = referable->id_short();
 
    if (id_short.has_value()) {
      if (id_short_set.find(*id_short) != id_short_set.end()) {
        return false;
      }
 
      id_short_set.insert(*id_short);
    }
  }
 
  return true;
}
 
bool IdShortsOfVariablesAreUnique(
  const common::optional<
    std::vector<
      std::shared_ptr<types::IOperationVariable>
    >
  >& input_variables,
  const common::optional<
    std::vector<
      std::shared_ptr<types::IOperationVariable>
    >
  >& output_variables,
  const common::optional<
    std::vector<
      std::shared_ptr<types::IOperationVariable>
    >
  >& inoutput_variables
);
 
bool ExtensionNamesAreUnique(
  const std::vector<
    std::shared_ptr<types::IExtension>
  >& extensions
);
 
bool SubmodelElementsHaveIdenticalSemanticIds(
  const std::vector<
    std::shared_ptr<types::ISubmodelElement>
  >& elements
);
 
bool SubmodelElementIsOfType(
  const std::shared_ptr<types::ISubmodelElement>& element,
  types::AasSubmodelElements element_type
);
 
bool PropertiesOrRangesHaveValueType(
  const std::vector<
    std::shared_ptr<types::ISubmodelElement>
  >& elements,
  types::DataTypeDefXsd value_type
);
 
bool ReferenceKeyValuesEqual(
  const std::shared_ptr<types::IReference>& that,
  const std::shared_ptr<types::IReference>& other
);
 
bool DataSpecificationIec61360sForPropertyOrValueHaveAppropriateDataType(
  const std::vector<
    std::shared_ptr<types::IEmbeddedDataSpecification>
  >& embedded_data_specifications
);
 
bool DataSpecificationIec61360sForReferenceHaveAppropriateDataType(
  const std::vector<
    std::shared_ptr<types::IEmbeddedDataSpecification>
  >& embedded_data_specifications
);
 
bool DataSpecificationIec61360sForDocumentHaveAppropriateDataType(
  const std::vector<
    std::shared_ptr<types::IEmbeddedDataSpecification>
  >& embedded_data_specifications
);
 
bool DataSpecificationIec61360sHaveDataType(
  const std::vector<
    std::shared_ptr<types::IEmbeddedDataSpecification>
  >& embedded_data_specifications
);
 
bool DataSpecificationIec61360sHaveValue(
  const std::vector<
    std::shared_ptr<types::IEmbeddedDataSpecification>
  >& embedded_data_specifications
);
 
bool DataSpecificationIec61360sHaveDefinitionAtLeastInEnglish(
  const std::vector<
    std::shared_ptr<types::IEmbeddedDataSpecification>
  >& embedded_data_specifications
);
 
bool IsBcp47ForEnglish(
  const std::wstring& text
);
 
// endregion Verification functions
 
// region Verification of constrained primitives
 
std::unique_ptr<IVerification> VerifyXmlSerializableString(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyNonEmptyXmlSerializableString(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyDateTimeUtc(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyDuration(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyBlobType(
  const std::vector<std::uint8_t>& that
);
 
std::unique_ptr<IVerification> VerifyIdentifier(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyValueTypeIec61360(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyNameType(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyVersionType(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyRevisionType(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyLabelType(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyMessageTopicType(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyBcp47LanguageTag(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyContentType(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyPathType(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyQualifierType(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyValueDataType(
  const std::wstring& that
);
 
std::unique_ptr<IVerification> VerifyIdShortType(
  const std::wstring& that
);
 
// endregion Verification of constrained primitives
 
}  // namespace verification
}  // namespace aas_3_1
}  // namespace aas_core
 
// This code has been automatically generated by aas-core-codegen.
// Do NOT edit or append.
 
#endif  // AAS_CORE_AAS_3_1_VERIFICATION_GUARD_