common_types.hh

#pragma once
 
#include <cstdint>
#include <memory>
#include <vector>
 
namespace learnta {
  typedef char Alphabet;
  typedef uint8_t ClockVariables;
  // Special action for unobservable transitions
  const Alphabet UNOBSERVABLE = 0;
  const auto UNOBSERVABLE_STRING = "ε";
 
  template<class State>
  struct Automaton {
    struct TATransition;
 
    std::vector<std::shared_ptr<State>> states;
    std::vector<std::shared_ptr<State>> initialStates;
 
    [[nodiscard]] inline std::size_t stateSize() const { return states.size(); }
 
    inline bool operator==(const Automaton<State> &A) const {
      return initialStates == A.initialStates && states == A.states;
    }
  };
 
  template<class T>
  bool is_ascending(const std::vector<T> &container) {
    static_assert(std::is_arithmetic<T>::value, "The elements must be arithmetic.");
    for (auto it = container.begin(); it != container.end() && std::next(it) != container.end(); ++it) {
      if (*it > *std::next(it)) {
        return false;
      }
    }
 
    return true;
  }
 
  template<class T>
  bool is_strict_ascending(const std::vector<T> &container) {
    static_assert(std::is_arithmetic<T>::value, "The elements must be arithmetic.");
    for (auto it = container.begin(); it != container.end() && std::next(it) != container.end(); ++it) {
      if (*it >= *std::next(it)) {
        return false;
      }
    }
 
    return true;
  }
 
  template<class T, class U>
  T first(const std::pair<T, U> &pair) {
    return pair.first;
  }
 
  template<class T, class U>
  U second(const std::pair<T, U> &pair) {
    return pair.second;
  }
 
  template<class T, class U>
  auto is_first(const T &value) {
    return [&] (const std::pair<T, U> &pair) {
      return pair.first == value;
    };
  }
 
  template<class T, class U>
  auto is_second(const U &value) {
    return [&] (const std::pair<T, U> &pair) {
      return pair.second == value;
    };
  }
}