verification.hpp

Go to the documentation of this file.

#ifndef AAS_CORE_AAS_3_0_VERIFICATION_GUARD_
#define AAS_CORE_AAS_3_0_VERIFICATION_GUARD_
 
// This code has been automatically generated by aas-core-codegen.
// Do NOT edit or append.
 
#include "aas_core/aas_3_0/common.hpp"
#include "aas_core/aas_3_0/iteration.hpp"
#include "aas_core/aas_3_0/pattern.hpp"
#include "aas_core/aas_3_0/types.hpp"
 
#pragma warning(push, 0)
#include <set>
#pragma warning(pop)
 
namespace aas_core {
namespace aas_3_0 {

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 MatchesRfc8089Path(
  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_0
}  // namespace aas_core
 
// This code has been automatically generated by aas-core-codegen.
// Do NOT edit or append.
 
#endif  // AAS_CORE_AAS_3_0_VERIFICATION_GUARD_