IAPDemo/Libraries/red_utils/FSM/StateMachineLoader/state_machine_config.pb.h

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: state_machine_config.proto

#ifndef GOOGLE_PROTOBUF_INCLUDED_state_5fmachine_5fconfig_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_state_5fmachine_5fconfig_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3015000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers. Please update
#error your headers.
#endif
#if 3015008 < PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers. Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/port_undef.inc>
#include <google/protobuf/io/coded_stream.h>
#include <google/protobuf/arena.h>
#include <google/protobuf/arenastring.h>
#include <google/protobuf/generated_message_table_driven.h>
#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/message_lite.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/map.h>  // IWYU pragma: export
#include <google/protobuf/map_entry_lite.h>
#include <google/protobuf/map_field_lite.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_state_5fmachine_5fconfig_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_state_5fmachine_5fconfig_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[9]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
};
namespace fsmproto {
class Action;
struct ActionDefaultTypeInternal;
extern ActionDefaultTypeInternal _Action_default_instance_;
class Action_ParamsEntry_DoNotUse;
struct Action_ParamsEntry_DoNotUseDefaultTypeInternal;
extern Action_ParamsEntry_DoNotUseDefaultTypeInternal _Action_ParamsEntry_DoNotUse_default_instance_;
class ConditionData;
struct ConditionDataDefaultTypeInternal;
extern ConditionDataDefaultTypeInternal _ConditionData_default_instance_;
class ConditionValue;
struct ConditionValueDefaultTypeInternal;
extern ConditionValueDefaultTypeInternal _ConditionValue_default_instance_;
class Param;
struct ParamDefaultTypeInternal;
extern ParamDefaultTypeInternal _Param_default_instance_;
class State;
struct StateDefaultTypeInternal;
extern StateDefaultTypeInternal _State_default_instance_;
class StateMachine;
struct StateMachineDefaultTypeInternal;
extern StateMachineDefaultTypeInternal _StateMachine_default_instance_;
class StateMachine_ParamsEntry_DoNotUse;
struct StateMachine_ParamsEntry_DoNotUseDefaultTypeInternal;
extern StateMachine_ParamsEntry_DoNotUseDefaultTypeInternal _StateMachine_ParamsEntry_DoNotUse_default_instance_;
class Transition;
struct TransitionDefaultTypeInternal;
extern TransitionDefaultTypeInternal _Transition_default_instance_;
}  // namespace fsmproto
PROTOBUF_NAMESPACE_OPEN
template<> ::fsmproto::Action* Arena::CreateMaybeMessage<::fsmproto::Action>(Arena*);
template<> ::fsmproto::Action_ParamsEntry_DoNotUse* Arena::CreateMaybeMessage<::fsmproto::Action_ParamsEntry_DoNotUse>(Arena*);
template<> ::fsmproto::ConditionData* Arena::CreateMaybeMessage<::fsmproto::ConditionData>(Arena*);
template<> ::fsmproto::ConditionValue* Arena::CreateMaybeMessage<::fsmproto::ConditionValue>(Arena*);
template<> ::fsmproto::Param* Arena::CreateMaybeMessage<::fsmproto::Param>(Arena*);
template<> ::fsmproto::State* Arena::CreateMaybeMessage<::fsmproto::State>(Arena*);
template<> ::fsmproto::StateMachine* Arena::CreateMaybeMessage<::fsmproto::StateMachine>(Arena*);
template<> ::fsmproto::StateMachine_ParamsEntry_DoNotUse* Arena::CreateMaybeMessage<::fsmproto::StateMachine_ParamsEntry_DoNotUse>(Arena*);
template<> ::fsmproto::Transition* Arena::CreateMaybeMessage<::fsmproto::Transition>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace fsmproto {

// ===================================================================

class Action_ParamsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<Action_ParamsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<Action_ParamsEntry_DoNotUse, 
    std::string, std::string,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> SuperType;
  Action_ParamsEntry_DoNotUse();
  explicit constexpr Action_ParamsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit Action_ParamsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const Action_ParamsEntry_DoNotUse& other);
  static const Action_ParamsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const Action_ParamsEntry_DoNotUse*>(&_Action_ParamsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "fsmproto.Action.ParamsEntry.key");
 }
  static bool ValidateValue(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "fsmproto.Action.ParamsEntry.value");
 }
};

// -------------------------------------------------------------------

class Action PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fsmproto.Action) */ {
 public:
  inline Action() : Action(nullptr) {}
  virtual ~Action();
  explicit constexpr Action(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Action(const Action& from);
  Action(Action&& from) noexcept
    : Action() {
    *this = ::std::move(from);
  }

  inline Action& operator=(const Action& from) {
    CopyFrom(from);
    return *this;
  }
  inline Action& operator=(Action&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const Action& default_instance() {
    return *internal_default_instance();
  }
  static inline const Action* internal_default_instance() {
    return reinterpret_cast<const Action*>(
               &_Action_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

  friend void swap(Action& a, Action& b) {
    a.Swap(&b);
  }
  inline void Swap(Action* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Action* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Action* New() const final {
    return CreateMaybeMessage<Action>(nullptr);
  }

  Action* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Action>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const Action& from);
  void MergeFrom(const Action& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Action* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "fsmproto.Action";
  }
  protected:
  explicit Action(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  enum : int {
    kParamsFieldNumber = 2,
    kTypeFieldNumber = 1,
  };
  // map<string, string> params = 2;
  int params_size() const;
  private:
  int _internal_params_size() const;
  public:
  void clear_params();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      _internal_params() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      _internal_mutable_params();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
      params() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
      mutable_params();

  // string type = 1;
  void clear_type();
  const std::string& type() const;
  void set_type(const std::string& value);
  void set_type(std::string&& value);
  void set_type(const char* value);
  void set_type(const char* value, size_t size);
  std::string* mutable_type();
  std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // @@protoc_insertion_point(class_scope:fsmproto.Action)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
      Action_ParamsEntry_DoNotUse,
      std::string, std::string,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING> params_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_state_5fmachine_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class ConditionValue PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fsmproto.ConditionValue) */ {
 public:
  inline ConditionValue() : ConditionValue(nullptr) {}
  virtual ~ConditionValue();
  explicit constexpr ConditionValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ConditionValue(const ConditionValue& from);
  ConditionValue(ConditionValue&& from) noexcept
    : ConditionValue() {
    *this = ::std::move(from);
  }

  inline ConditionValue& operator=(const ConditionValue& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConditionValue& operator=(ConditionValue&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ConditionValue& default_instance() {
    return *internal_default_instance();
  }
  static inline const ConditionValue* internal_default_instance() {
    return reinterpret_cast<const ConditionValue*>(
               &_ConditionValue_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

  friend void swap(ConditionValue& a, ConditionValue& b) {
    a.Swap(&b);
  }
  inline void Swap(ConditionValue* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConditionValue* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ConditionValue* New() const final {
    return CreateMaybeMessage<ConditionValue>(nullptr);
  }

  ConditionValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ConditionValue>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const ConditionValue& from);
  void MergeFrom(const ConditionValue& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ConditionValue* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "fsmproto.ConditionValue";
  }
  protected:
  explicit ConditionValue(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kParamNameFieldNumber = 1,
    kSymbolFieldNumber = 2,
    kCompareValueFieldNumber = 3,
  };
  // string param_name = 1;
  void clear_param_name();
  const std::string& param_name() const;
  void set_param_name(const std::string& value);
  void set_param_name(std::string&& value);
  void set_param_name(const char* value);
  void set_param_name(const char* value, size_t size);
  std::string* mutable_param_name();
  std::string* release_param_name();
  void set_allocated_param_name(std::string* param_name);
  private:
  const std::string& _internal_param_name() const;
  void _internal_set_param_name(const std::string& value);
  std::string* _internal_mutable_param_name();
  public:

  // string symbol = 2;
  void clear_symbol();
  const std::string& symbol() const;
  void set_symbol(const std::string& value);
  void set_symbol(std::string&& value);
  void set_symbol(const char* value);
  void set_symbol(const char* value, size_t size);
  std::string* mutable_symbol();
  std::string* release_symbol();
  void set_allocated_symbol(std::string* symbol);
  private:
  const std::string& _internal_symbol() const;
  void _internal_set_symbol(const std::string& value);
  std::string* _internal_mutable_symbol();
  public:

  // string compare_value = 3;
  void clear_compare_value();
  const std::string& compare_value() const;
  void set_compare_value(const std::string& value);
  void set_compare_value(std::string&& value);
  void set_compare_value(const char* value);
  void set_compare_value(const char* value, size_t size);
  std::string* mutable_compare_value();
  std::string* release_compare_value();
  void set_allocated_compare_value(std::string* compare_value);
  private:
  const std::string& _internal_compare_value() const;
  void _internal_set_compare_value(const std::string& value);
  std::string* _internal_mutable_compare_value();
  public:

  // @@protoc_insertion_point(class_scope:fsmproto.ConditionValue)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr param_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr symbol_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr compare_value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_state_5fmachine_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class ConditionData PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fsmproto.ConditionData) */ {
 public:
  inline ConditionData() : ConditionData(nullptr) {}
  virtual ~ConditionData();
  explicit constexpr ConditionData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  ConditionData(const ConditionData& from);
  ConditionData(ConditionData&& from) noexcept
    : ConditionData() {
    *this = ::std::move(from);
  }

  inline ConditionData& operator=(const ConditionData& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConditionData& operator=(ConditionData&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const ConditionData& default_instance() {
    return *internal_default_instance();
  }
  static inline const ConditionData* internal_default_instance() {
    return reinterpret_cast<const ConditionData*>(
               &_ConditionData_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

  friend void swap(ConditionData& a, ConditionData& b) {
    a.Swap(&b);
  }
  inline void Swap(ConditionData* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(ConditionData* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline ConditionData* New() const final {
    return CreateMaybeMessage<ConditionData>(nullptr);
  }

  ConditionData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ConditionData>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const ConditionData& from);
  void MergeFrom(const ConditionData& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(ConditionData* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "fsmproto.ConditionData";
  }
  protected:
  explicit ConditionData(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kValuesFieldNumber = 1,
  };
  // repeated .fsmproto.ConditionValue values = 1;
  int values_size() const;
  private:
  int _internal_values_size() const;
  public:
  void clear_values();
  ::fsmproto::ConditionValue* mutable_values(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::ConditionValue >*
      mutable_values();
  private:
  const ::fsmproto::ConditionValue& _internal_values(int index) const;
  ::fsmproto::ConditionValue* _internal_add_values();
  public:
  const ::fsmproto::ConditionValue& values(int index) const;
  ::fsmproto::ConditionValue* add_values();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::ConditionValue >&
      values() const;

  // @@protoc_insertion_point(class_scope:fsmproto.ConditionData)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::ConditionValue > values_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_state_5fmachine_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class Transition PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fsmproto.Transition) */ {
 public:
  inline Transition() : Transition(nullptr) {}
  virtual ~Transition();
  explicit constexpr Transition(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Transition(const Transition& from);
  Transition(Transition&& from) noexcept
    : Transition() {
    *this = ::std::move(from);
  }

  inline Transition& operator=(const Transition& from) {
    CopyFrom(from);
    return *this;
  }
  inline Transition& operator=(Transition&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const Transition& default_instance() {
    return *internal_default_instance();
  }
  static inline const Transition* internal_default_instance() {
    return reinterpret_cast<const Transition*>(
               &_Transition_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

  friend void swap(Transition& a, Transition& b) {
    a.Swap(&b);
  }
  inline void Swap(Transition* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Transition* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Transition* New() const final {
    return CreateMaybeMessage<Transition>(nullptr);
  }

  Transition* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Transition>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const Transition& from);
  void MergeFrom(const Transition& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Transition* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "fsmproto.Transition";
  }
  protected:
  explicit Transition(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kConditionFieldNumber = 4,
    kBeforeSwitchActionsFieldNumber = 5,
    kAfterSwitchActionsFieldNumber = 6,
    kSrcFieldNumber = 1,
    kDstFieldNumber = 2,
    kEventFieldNumber = 3,
  };
  // repeated .fsmproto.ConditionData condition = 4;
  int condition_size() const;
  private:
  int _internal_condition_size() const;
  public:
  void clear_condition();
  ::fsmproto::ConditionData* mutable_condition(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::ConditionData >*
      mutable_condition();
  private:
  const ::fsmproto::ConditionData& _internal_condition(int index) const;
  ::fsmproto::ConditionData* _internal_add_condition();
  public:
  const ::fsmproto::ConditionData& condition(int index) const;
  ::fsmproto::ConditionData* add_condition();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::ConditionData >&
      condition() const;

  // repeated .fsmproto.Action before_switch_actions = 5;
  int before_switch_actions_size() const;
  private:
  int _internal_before_switch_actions_size() const;
  public:
  void clear_before_switch_actions();
  ::fsmproto::Action* mutable_before_switch_actions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >*
      mutable_before_switch_actions();
  private:
  const ::fsmproto::Action& _internal_before_switch_actions(int index) const;
  ::fsmproto::Action* _internal_add_before_switch_actions();
  public:
  const ::fsmproto::Action& before_switch_actions(int index) const;
  ::fsmproto::Action* add_before_switch_actions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >&
      before_switch_actions() const;

  // repeated .fsmproto.Action after_switch_actions = 6;
  int after_switch_actions_size() const;
  private:
  int _internal_after_switch_actions_size() const;
  public:
  void clear_after_switch_actions();
  ::fsmproto::Action* mutable_after_switch_actions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >*
      mutable_after_switch_actions();
  private:
  const ::fsmproto::Action& _internal_after_switch_actions(int index) const;
  ::fsmproto::Action* _internal_add_after_switch_actions();
  public:
  const ::fsmproto::Action& after_switch_actions(int index) const;
  ::fsmproto::Action* add_after_switch_actions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >&
      after_switch_actions() const;

  // string src = 1;
  void clear_src();
  const std::string& src() const;
  void set_src(const std::string& value);
  void set_src(std::string&& value);
  void set_src(const char* value);
  void set_src(const char* value, size_t size);
  std::string* mutable_src();
  std::string* release_src();
  void set_allocated_src(std::string* src);
  private:
  const std::string& _internal_src() const;
  void _internal_set_src(const std::string& value);
  std::string* _internal_mutable_src();
  public:

  // string dst = 2;
  void clear_dst();
  const std::string& dst() const;
  void set_dst(const std::string& value);
  void set_dst(std::string&& value);
  void set_dst(const char* value);
  void set_dst(const char* value, size_t size);
  std::string* mutable_dst();
  std::string* release_dst();
  void set_allocated_dst(std::string* dst);
  private:
  const std::string& _internal_dst() const;
  void _internal_set_dst(const std::string& value);
  std::string* _internal_mutable_dst();
  public:

  // string event = 3;
  void clear_event();
  const std::string& event() const;
  void set_event(const std::string& value);
  void set_event(std::string&& value);
  void set_event(const char* value);
  void set_event(const char* value, size_t size);
  std::string* mutable_event();
  std::string* release_event();
  void set_allocated_event(std::string* event);
  private:
  const std::string& _internal_event() const;
  void _internal_set_event(const std::string& value);
  std::string* _internal_mutable_event();
  public:

  // @@protoc_insertion_point(class_scope:fsmproto.Transition)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::ConditionData > condition_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action > before_switch_actions_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action > after_switch_actions_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr src_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dst_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr event_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_state_5fmachine_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class State PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fsmproto.State) */ {
 public:
  inline State() : State(nullptr) {}
  virtual ~State();
  explicit constexpr State(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  State(const State& from);
  State(State&& from) noexcept
    : State() {
    *this = ::std::move(from);
  }

  inline State& operator=(const State& from) {
    CopyFrom(from);
    return *this;
  }
  inline State& operator=(State&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const State& default_instance() {
    return *internal_default_instance();
  }
  static inline const State* internal_default_instance() {
    return reinterpret_cast<const State*>(
               &_State_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

  friend void swap(State& a, State& b) {
    a.Swap(&b);
  }
  inline void Swap(State* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(State* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline State* New() const final {
    return CreateMaybeMessage<State>(nullptr);
  }

  State* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<State>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const State& from);
  void MergeFrom(const State& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(State* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "fsmproto.State";
  }
  protected:
  explicit State(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kEntryFieldNumber = 2,
    kIdleFieldNumber = 3,
    kExitFieldNumber = 4,
    kNameFieldNumber = 1,
    kFsmNameFieldNumber = 5,
    kStateDelegateKeyFieldNumber = 6,
  };
  // repeated .fsmproto.Action entry = 2;
  int entry_size() const;
  private:
  int _internal_entry_size() const;
  public:
  void clear_entry();
  ::fsmproto::Action* mutable_entry(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >*
      mutable_entry();
  private:
  const ::fsmproto::Action& _internal_entry(int index) const;
  ::fsmproto::Action* _internal_add_entry();
  public:
  const ::fsmproto::Action& entry(int index) const;
  ::fsmproto::Action* add_entry();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >&
      entry() const;

  // repeated .fsmproto.Action idle = 3;
  int idle_size() const;
  private:
  int _internal_idle_size() const;
  public:
  void clear_idle();
  ::fsmproto::Action* mutable_idle(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >*
      mutable_idle();
  private:
  const ::fsmproto::Action& _internal_idle(int index) const;
  ::fsmproto::Action* _internal_add_idle();
  public:
  const ::fsmproto::Action& idle(int index) const;
  ::fsmproto::Action* add_idle();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >&
      idle() const;

  // repeated .fsmproto.Action exit = 4;
  int exit_size() const;
  private:
  int _internal_exit_size() const;
  public:
  void clear_exit();
  ::fsmproto::Action* mutable_exit(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >*
      mutable_exit();
  private:
  const ::fsmproto::Action& _internal_exit(int index) const;
  ::fsmproto::Action* _internal_add_exit();
  public:
  const ::fsmproto::Action& exit(int index) const;
  ::fsmproto::Action* add_exit();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >&
      exit() const;

  // string name = 1;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // string fsm_name = 5;
  void clear_fsm_name();
  const std::string& fsm_name() const;
  void set_fsm_name(const std::string& value);
  void set_fsm_name(std::string&& value);
  void set_fsm_name(const char* value);
  void set_fsm_name(const char* value, size_t size);
  std::string* mutable_fsm_name();
  std::string* release_fsm_name();
  void set_allocated_fsm_name(std::string* fsm_name);
  private:
  const std::string& _internal_fsm_name() const;
  void _internal_set_fsm_name(const std::string& value);
  std::string* _internal_mutable_fsm_name();
  public:

  // string state_delegate_key = 6;
  void clear_state_delegate_key();
  const std::string& state_delegate_key() const;
  void set_state_delegate_key(const std::string& value);
  void set_state_delegate_key(std::string&& value);
  void set_state_delegate_key(const char* value);
  void set_state_delegate_key(const char* value, size_t size);
  std::string* mutable_state_delegate_key();
  std::string* release_state_delegate_key();
  void set_allocated_state_delegate_key(std::string* state_delegate_key);
  private:
  const std::string& _internal_state_delegate_key() const;
  void _internal_set_state_delegate_key(const std::string& value);
  std::string* _internal_mutable_state_delegate_key();
  public:

  // @@protoc_insertion_point(class_scope:fsmproto.State)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action > entry_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action > idle_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action > exit_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr fsm_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr state_delegate_key_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_state_5fmachine_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class Param PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fsmproto.Param) */ {
 public:
  inline Param() : Param(nullptr) {}
  virtual ~Param();
  explicit constexpr Param(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  Param(const Param& from);
  Param(Param&& from) noexcept
    : Param() {
    *this = ::std::move(from);
  }

  inline Param& operator=(const Param& from) {
    CopyFrom(from);
    return *this;
  }
  inline Param& operator=(Param&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const Param& default_instance() {
    return *internal_default_instance();
  }
  static inline const Param* internal_default_instance() {
    return reinterpret_cast<const Param*>(
               &_Param_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

  friend void swap(Param& a, Param& b) {
    a.Swap(&b);
  }
  inline void Swap(Param* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(Param* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline Param* New() const final {
    return CreateMaybeMessage<Param>(nullptr);
  }

  Param* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Param>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const Param& from);
  void MergeFrom(const Param& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(Param* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "fsmproto.Param";
  }
  protected:
  explicit Param(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------

  // accessors -------------------------------------------------------

  enum : int {
    kTypeFieldNumber = 1,
    kDefaultValueFieldNumber = 2,
  };
  // string type = 1;
  void clear_type();
  const std::string& type() const;
  void set_type(const std::string& value);
  void set_type(std::string&& value);
  void set_type(const char* value);
  void set_type(const char* value, size_t size);
  std::string* mutable_type();
  std::string* release_type();
  void set_allocated_type(std::string* type);
  private:
  const std::string& _internal_type() const;
  void _internal_set_type(const std::string& value);
  std::string* _internal_mutable_type();
  public:

  // string default_value = 2;
  void clear_default_value();
  const std::string& default_value() const;
  void set_default_value(const std::string& value);
  void set_default_value(std::string&& value);
  void set_default_value(const char* value);
  void set_default_value(const char* value, size_t size);
  std::string* mutable_default_value();
  std::string* release_default_value();
  void set_allocated_default_value(std::string* default_value);
  private:
  const std::string& _internal_default_value() const;
  void _internal_set_default_value(const std::string& value);
  std::string* _internal_mutable_default_value();
  public:

  // @@protoc_insertion_point(class_scope:fsmproto.Param)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr default_value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_state_5fmachine_5fconfig_2eproto;
};
// -------------------------------------------------------------------

class StateMachine_ParamsEntry_DoNotUse : public ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<StateMachine_ParamsEntry_DoNotUse, 
    std::string, ::fsmproto::Param,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> {
public:
  typedef ::PROTOBUF_NAMESPACE_ID::internal::MapEntryLite<StateMachine_ParamsEntry_DoNotUse, 
    std::string, ::fsmproto::Param,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
    ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> SuperType;
  StateMachine_ParamsEntry_DoNotUse();
  explicit constexpr StateMachine_ParamsEntry_DoNotUse(
      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
  explicit StateMachine_ParamsEntry_DoNotUse(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  void MergeFrom(const StateMachine_ParamsEntry_DoNotUse& other);
  static const StateMachine_ParamsEntry_DoNotUse* internal_default_instance() { return reinterpret_cast<const StateMachine_ParamsEntry_DoNotUse*>(&_StateMachine_ParamsEntry_DoNotUse_default_instance_); }
  static bool ValidateKey(std::string* s) {
    return ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::VerifyUtf8String(s->data(), static_cast<int>(s->size()), ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::PARSE, "fsmproto.StateMachine.ParamsEntry.key");
 }
  static bool ValidateValue(void*) { return true; }
};

// -------------------------------------------------------------------

class StateMachine PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:fsmproto.StateMachine) */ {
 public:
  inline StateMachine() : StateMachine(nullptr) {}
  virtual ~StateMachine();
  explicit constexpr StateMachine(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);

  StateMachine(const StateMachine& from);
  StateMachine(StateMachine&& from) noexcept
    : StateMachine() {
    *this = ::std::move(from);
  }

  inline StateMachine& operator=(const StateMachine& from) {
    CopyFrom(from);
    return *this;
  }
  inline StateMachine& operator=(StateMachine&& from) noexcept {
    if (GetArena() == from.GetArena()) {
      if (this != &from) InternalSwap(&from);
    } else {
      CopyFrom(from);
    }
    return *this;
  }

  static const StateMachine& default_instance() {
    return *internal_default_instance();
  }
  static inline const StateMachine* internal_default_instance() {
    return reinterpret_cast<const StateMachine*>(
               &_StateMachine_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    8;

  friend void swap(StateMachine& a, StateMachine& b) {
    a.Swap(&b);
  }
  inline void Swap(StateMachine* other) {
    if (other == this) return;
    if (GetArena() == other->GetArena()) {
      InternalSwap(other);
    } else {
      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
    }
  }
  void UnsafeArenaSwap(StateMachine* other) {
    if (other == this) return;
    GOOGLE_DCHECK(GetArena() == other->GetArena());
    InternalSwap(other);
  }

  // implements Message ----------------------------------------------

  inline StateMachine* New() const final {
    return CreateMaybeMessage<StateMachine>(nullptr);
  }

  StateMachine* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<StateMachine>(arena);
  }
  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)
    final;
  void CopyFrom(const StateMachine& from);
  void MergeFrom(const StateMachine& from);
  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
  bool IsInitialized() const final;

  size_t ByteSizeLong() const final;
  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
  void DiscardUnknownFields();
  int GetCachedSize() const final { return _cached_size_.Get(); }

  private:
  inline void SharedCtor();
  inline void SharedDtor();
  void SetCachedSize(int size) const;
  void InternalSwap(StateMachine* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "fsmproto.StateMachine";
  }
  protected:
  explicit StateMachine(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  private:
  static void ArenaDtor(void* object);
  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
  public:

  std::string GetTypeName() const final;

  // nested types ----------------------------------------------------


  // accessors -------------------------------------------------------

  enum : int {
    kParamsFieldNumber = 3,
    kStatesFieldNumber = 4,
    kTransitionsFieldNumber = 5,
    kInitStateNameFieldNumber = 1,
    kMachineTypeFieldNumber = 2,
  };
  // map<string, .fsmproto.Param> params = 3;
  int params_size() const;
  private:
  int _internal_params_size() const;
  public:
  void clear_params();
  private:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >&
      _internal_params() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >*
      _internal_mutable_params();
  public:
  const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >&
      params() const;
  ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >*
      mutable_params();

  // repeated .fsmproto.State states = 4;
  int states_size() const;
  private:
  int _internal_states_size() const;
  public:
  void clear_states();
  ::fsmproto::State* mutable_states(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::State >*
      mutable_states();
  private:
  const ::fsmproto::State& _internal_states(int index) const;
  ::fsmproto::State* _internal_add_states();
  public:
  const ::fsmproto::State& states(int index) const;
  ::fsmproto::State* add_states();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::State >&
      states() const;

  // repeated .fsmproto.Transition transitions = 5;
  int transitions_size() const;
  private:
  int _internal_transitions_size() const;
  public:
  void clear_transitions();
  ::fsmproto::Transition* mutable_transitions(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Transition >*
      mutable_transitions();
  private:
  const ::fsmproto::Transition& _internal_transitions(int index) const;
  ::fsmproto::Transition* _internal_add_transitions();
  public:
  const ::fsmproto::Transition& transitions(int index) const;
  ::fsmproto::Transition* add_transitions();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Transition >&
      transitions() const;

  // string init_state_name = 1;
  void clear_init_state_name();
  const std::string& init_state_name() const;
  void set_init_state_name(const std::string& value);
  void set_init_state_name(std::string&& value);
  void set_init_state_name(const char* value);
  void set_init_state_name(const char* value, size_t size);
  std::string* mutable_init_state_name();
  std::string* release_init_state_name();
  void set_allocated_init_state_name(std::string* init_state_name);
  private:
  const std::string& _internal_init_state_name() const;
  void _internal_set_init_state_name(const std::string& value);
  std::string* _internal_mutable_init_state_name();
  public:

  // string machine_type = 2;
  void clear_machine_type();
  const std::string& machine_type() const;
  void set_machine_type(const std::string& value);
  void set_machine_type(std::string&& value);
  void set_machine_type(const char* value);
  void set_machine_type(const char* value, size_t size);
  std::string* mutable_machine_type();
  std::string* release_machine_type();
  void set_allocated_machine_type(std::string* machine_type);
  private:
  const std::string& _internal_machine_type() const;
  void _internal_set_machine_type(const std::string& value);
  std::string* _internal_mutable_machine_type();
  public:

  // @@protoc_insertion_point(class_scope:fsmproto.StateMachine)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::MapFieldLite<
      StateMachine_ParamsEntry_DoNotUse,
      std::string, ::fsmproto::Param,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_STRING,
      ::PROTOBUF_NAMESPACE_ID::internal::WireFormatLite::TYPE_MESSAGE> params_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::State > states_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Transition > transitions_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr init_state_name_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr machine_type_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_state_5fmachine_5fconfig_2eproto;
};
// ===================================================================


// ===================================================================

#ifdef __GNUC__
  #pragma GCC diagnostic push
  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif  // __GNUC__
// -------------------------------------------------------------------

// Action

// string type = 1;
inline void Action::clear_type() {
  type_.ClearToEmpty();
}
inline const std::string& Action::type() const {
  // @@protoc_insertion_point(field_get:fsmproto.Action.type)
  return _internal_type();
}
inline void Action::set_type(const std::string& value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:fsmproto.Action.type)
}
inline std::string* Action::mutable_type() {
  // @@protoc_insertion_point(field_mutable:fsmproto.Action.type)
  return _internal_mutable_type();
}
inline const std::string& Action::_internal_type() const {
  return type_.Get();
}
inline void Action::_internal_set_type(const std::string& value) {
  
  type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Action::set_type(std::string&& value) {
  
  type_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.Action.type)
}
inline void Action::set_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.Action.type)
}
inline void Action::set_type(const char* value,
    size_t size) {
  
  type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.Action.type)
}
inline std::string* Action::_internal_mutable_type() {
  
  return type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Action::release_type() {
  // @@protoc_insertion_point(field_release:fsmproto.Action.type)
  return type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Action::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.Action.type)
}

// map<string, string> params = 2;
inline int Action::_internal_params_size() const {
  return params_.size();
}
inline int Action::params_size() const {
  return _internal_params_size();
}
inline void Action::clear_params() {
  params_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
Action::_internal_params() const {
  return params_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >&
Action::params() const {
  // @@protoc_insertion_point(field_map:fsmproto.Action.params)
  return _internal_params();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
Action::_internal_mutable_params() {
  return params_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, std::string >*
Action::mutable_params() {
  // @@protoc_insertion_point(field_mutable_map:fsmproto.Action.params)
  return _internal_mutable_params();
}

// -------------------------------------------------------------------

// ConditionValue

// string param_name = 1;
inline void ConditionValue::clear_param_name() {
  param_name_.ClearToEmpty();
}
inline const std::string& ConditionValue::param_name() const {
  // @@protoc_insertion_point(field_get:fsmproto.ConditionValue.param_name)
  return _internal_param_name();
}
inline void ConditionValue::set_param_name(const std::string& value) {
  _internal_set_param_name(value);
  // @@protoc_insertion_point(field_set:fsmproto.ConditionValue.param_name)
}
inline std::string* ConditionValue::mutable_param_name() {
  // @@protoc_insertion_point(field_mutable:fsmproto.ConditionValue.param_name)
  return _internal_mutable_param_name();
}
inline const std::string& ConditionValue::_internal_param_name() const {
  return param_name_.Get();
}
inline void ConditionValue::_internal_set_param_name(const std::string& value) {
  
  param_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ConditionValue::set_param_name(std::string&& value) {
  
  param_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.ConditionValue.param_name)
}
inline void ConditionValue::set_param_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  param_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.ConditionValue.param_name)
}
inline void ConditionValue::set_param_name(const char* value,
    size_t size) {
  
  param_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.ConditionValue.param_name)
}
inline std::string* ConditionValue::_internal_mutable_param_name() {
  
  return param_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ConditionValue::release_param_name() {
  // @@protoc_insertion_point(field_release:fsmproto.ConditionValue.param_name)
  return param_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ConditionValue::set_allocated_param_name(std::string* param_name) {
  if (param_name != nullptr) {
    
  } else {
    
  }
  param_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), param_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.ConditionValue.param_name)
}

// string symbol = 2;
inline void ConditionValue::clear_symbol() {
  symbol_.ClearToEmpty();
}
inline const std::string& ConditionValue::symbol() const {
  // @@protoc_insertion_point(field_get:fsmproto.ConditionValue.symbol)
  return _internal_symbol();
}
inline void ConditionValue::set_symbol(const std::string& value) {
  _internal_set_symbol(value);
  // @@protoc_insertion_point(field_set:fsmproto.ConditionValue.symbol)
}
inline std::string* ConditionValue::mutable_symbol() {
  // @@protoc_insertion_point(field_mutable:fsmproto.ConditionValue.symbol)
  return _internal_mutable_symbol();
}
inline const std::string& ConditionValue::_internal_symbol() const {
  return symbol_.Get();
}
inline void ConditionValue::_internal_set_symbol(const std::string& value) {
  
  symbol_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ConditionValue::set_symbol(std::string&& value) {
  
  symbol_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.ConditionValue.symbol)
}
inline void ConditionValue::set_symbol(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  symbol_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.ConditionValue.symbol)
}
inline void ConditionValue::set_symbol(const char* value,
    size_t size) {
  
  symbol_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.ConditionValue.symbol)
}
inline std::string* ConditionValue::_internal_mutable_symbol() {
  
  return symbol_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ConditionValue::release_symbol() {
  // @@protoc_insertion_point(field_release:fsmproto.ConditionValue.symbol)
  return symbol_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ConditionValue::set_allocated_symbol(std::string* symbol) {
  if (symbol != nullptr) {
    
  } else {
    
  }
  symbol_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), symbol,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.ConditionValue.symbol)
}

// string compare_value = 3;
inline void ConditionValue::clear_compare_value() {
  compare_value_.ClearToEmpty();
}
inline const std::string& ConditionValue::compare_value() const {
  // @@protoc_insertion_point(field_get:fsmproto.ConditionValue.compare_value)
  return _internal_compare_value();
}
inline void ConditionValue::set_compare_value(const std::string& value) {
  _internal_set_compare_value(value);
  // @@protoc_insertion_point(field_set:fsmproto.ConditionValue.compare_value)
}
inline std::string* ConditionValue::mutable_compare_value() {
  // @@protoc_insertion_point(field_mutable:fsmproto.ConditionValue.compare_value)
  return _internal_mutable_compare_value();
}
inline const std::string& ConditionValue::_internal_compare_value() const {
  return compare_value_.Get();
}
inline void ConditionValue::_internal_set_compare_value(const std::string& value) {
  
  compare_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void ConditionValue::set_compare_value(std::string&& value) {
  
  compare_value_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.ConditionValue.compare_value)
}
inline void ConditionValue::set_compare_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  compare_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.ConditionValue.compare_value)
}
inline void ConditionValue::set_compare_value(const char* value,
    size_t size) {
  
  compare_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.ConditionValue.compare_value)
}
inline std::string* ConditionValue::_internal_mutable_compare_value() {
  
  return compare_value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* ConditionValue::release_compare_value() {
  // @@protoc_insertion_point(field_release:fsmproto.ConditionValue.compare_value)
  return compare_value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void ConditionValue::set_allocated_compare_value(std::string* compare_value) {
  if (compare_value != nullptr) {
    
  } else {
    
  }
  compare_value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), compare_value,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.ConditionValue.compare_value)
}

// -------------------------------------------------------------------

// ConditionData

// repeated .fsmproto.ConditionValue values = 1;
inline int ConditionData::_internal_values_size() const {
  return values_.size();
}
inline int ConditionData::values_size() const {
  return _internal_values_size();
}
inline void ConditionData::clear_values() {
  values_.Clear();
}
inline ::fsmproto::ConditionValue* ConditionData::mutable_values(int index) {
  // @@protoc_insertion_point(field_mutable:fsmproto.ConditionData.values)
  return values_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::ConditionValue >*
ConditionData::mutable_values() {
  // @@protoc_insertion_point(field_mutable_list:fsmproto.ConditionData.values)
  return &values_;
}
inline const ::fsmproto::ConditionValue& ConditionData::_internal_values(int index) const {
  return values_.Get(index);
}
inline const ::fsmproto::ConditionValue& ConditionData::values(int index) const {
  // @@protoc_insertion_point(field_get:fsmproto.ConditionData.values)
  return _internal_values(index);
}
inline ::fsmproto::ConditionValue* ConditionData::_internal_add_values() {
  return values_.Add();
}
inline ::fsmproto::ConditionValue* ConditionData::add_values() {
  // @@protoc_insertion_point(field_add:fsmproto.ConditionData.values)
  return _internal_add_values();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::ConditionValue >&
ConditionData::values() const {
  // @@protoc_insertion_point(field_list:fsmproto.ConditionData.values)
  return values_;
}

// -------------------------------------------------------------------

// Transition

// string src = 1;
inline void Transition::clear_src() {
  src_.ClearToEmpty();
}
inline const std::string& Transition::src() const {
  // @@protoc_insertion_point(field_get:fsmproto.Transition.src)
  return _internal_src();
}
inline void Transition::set_src(const std::string& value) {
  _internal_set_src(value);
  // @@protoc_insertion_point(field_set:fsmproto.Transition.src)
}
inline std::string* Transition::mutable_src() {
  // @@protoc_insertion_point(field_mutable:fsmproto.Transition.src)
  return _internal_mutable_src();
}
inline const std::string& Transition::_internal_src() const {
  return src_.Get();
}
inline void Transition::_internal_set_src(const std::string& value) {
  
  src_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Transition::set_src(std::string&& value) {
  
  src_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.Transition.src)
}
inline void Transition::set_src(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  src_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.Transition.src)
}
inline void Transition::set_src(const char* value,
    size_t size) {
  
  src_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.Transition.src)
}
inline std::string* Transition::_internal_mutable_src() {
  
  return src_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Transition::release_src() {
  // @@protoc_insertion_point(field_release:fsmproto.Transition.src)
  return src_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Transition::set_allocated_src(std::string* src) {
  if (src != nullptr) {
    
  } else {
    
  }
  src_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), src,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.Transition.src)
}

// string dst = 2;
inline void Transition::clear_dst() {
  dst_.ClearToEmpty();
}
inline const std::string& Transition::dst() const {
  // @@protoc_insertion_point(field_get:fsmproto.Transition.dst)
  return _internal_dst();
}
inline void Transition::set_dst(const std::string& value) {
  _internal_set_dst(value);
  // @@protoc_insertion_point(field_set:fsmproto.Transition.dst)
}
inline std::string* Transition::mutable_dst() {
  // @@protoc_insertion_point(field_mutable:fsmproto.Transition.dst)
  return _internal_mutable_dst();
}
inline const std::string& Transition::_internal_dst() const {
  return dst_.Get();
}
inline void Transition::_internal_set_dst(const std::string& value) {
  
  dst_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Transition::set_dst(std::string&& value) {
  
  dst_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.Transition.dst)
}
inline void Transition::set_dst(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  dst_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.Transition.dst)
}
inline void Transition::set_dst(const char* value,
    size_t size) {
  
  dst_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.Transition.dst)
}
inline std::string* Transition::_internal_mutable_dst() {
  
  return dst_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Transition::release_dst() {
  // @@protoc_insertion_point(field_release:fsmproto.Transition.dst)
  return dst_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Transition::set_allocated_dst(std::string* dst) {
  if (dst != nullptr) {
    
  } else {
    
  }
  dst_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), dst,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.Transition.dst)
}

// string event = 3;
inline void Transition::clear_event() {
  event_.ClearToEmpty();
}
inline const std::string& Transition::event() const {
  // @@protoc_insertion_point(field_get:fsmproto.Transition.event)
  return _internal_event();
}
inline void Transition::set_event(const std::string& value) {
  _internal_set_event(value);
  // @@protoc_insertion_point(field_set:fsmproto.Transition.event)
}
inline std::string* Transition::mutable_event() {
  // @@protoc_insertion_point(field_mutable:fsmproto.Transition.event)
  return _internal_mutable_event();
}
inline const std::string& Transition::_internal_event() const {
  return event_.Get();
}
inline void Transition::_internal_set_event(const std::string& value) {
  
  event_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Transition::set_event(std::string&& value) {
  
  event_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.Transition.event)
}
inline void Transition::set_event(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  event_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.Transition.event)
}
inline void Transition::set_event(const char* value,
    size_t size) {
  
  event_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.Transition.event)
}
inline std::string* Transition::_internal_mutable_event() {
  
  return event_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Transition::release_event() {
  // @@protoc_insertion_point(field_release:fsmproto.Transition.event)
  return event_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Transition::set_allocated_event(std::string* event) {
  if (event != nullptr) {
    
  } else {
    
  }
  event_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), event,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.Transition.event)
}

// repeated .fsmproto.ConditionData condition = 4;
inline int Transition::_internal_condition_size() const {
  return condition_.size();
}
inline int Transition::condition_size() const {
  return _internal_condition_size();
}
inline void Transition::clear_condition() {
  condition_.Clear();
}
inline ::fsmproto::ConditionData* Transition::mutable_condition(int index) {
  // @@protoc_insertion_point(field_mutable:fsmproto.Transition.condition)
  return condition_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::ConditionData >*
Transition::mutable_condition() {
  // @@protoc_insertion_point(field_mutable_list:fsmproto.Transition.condition)
  return &condition_;
}
inline const ::fsmproto::ConditionData& Transition::_internal_condition(int index) const {
  return condition_.Get(index);
}
inline const ::fsmproto::ConditionData& Transition::condition(int index) const {
  // @@protoc_insertion_point(field_get:fsmproto.Transition.condition)
  return _internal_condition(index);
}
inline ::fsmproto::ConditionData* Transition::_internal_add_condition() {
  return condition_.Add();
}
inline ::fsmproto::ConditionData* Transition::add_condition() {
  // @@protoc_insertion_point(field_add:fsmproto.Transition.condition)
  return _internal_add_condition();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::ConditionData >&
Transition::condition() const {
  // @@protoc_insertion_point(field_list:fsmproto.Transition.condition)
  return condition_;
}

// repeated .fsmproto.Action before_switch_actions = 5;
inline int Transition::_internal_before_switch_actions_size() const {
  return before_switch_actions_.size();
}
inline int Transition::before_switch_actions_size() const {
  return _internal_before_switch_actions_size();
}
inline void Transition::clear_before_switch_actions() {
  before_switch_actions_.Clear();
}
inline ::fsmproto::Action* Transition::mutable_before_switch_actions(int index) {
  // @@protoc_insertion_point(field_mutable:fsmproto.Transition.before_switch_actions)
  return before_switch_actions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >*
Transition::mutable_before_switch_actions() {
  // @@protoc_insertion_point(field_mutable_list:fsmproto.Transition.before_switch_actions)
  return &before_switch_actions_;
}
inline const ::fsmproto::Action& Transition::_internal_before_switch_actions(int index) const {
  return before_switch_actions_.Get(index);
}
inline const ::fsmproto::Action& Transition::before_switch_actions(int index) const {
  // @@protoc_insertion_point(field_get:fsmproto.Transition.before_switch_actions)
  return _internal_before_switch_actions(index);
}
inline ::fsmproto::Action* Transition::_internal_add_before_switch_actions() {
  return before_switch_actions_.Add();
}
inline ::fsmproto::Action* Transition::add_before_switch_actions() {
  // @@protoc_insertion_point(field_add:fsmproto.Transition.before_switch_actions)
  return _internal_add_before_switch_actions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >&
Transition::before_switch_actions() const {
  // @@protoc_insertion_point(field_list:fsmproto.Transition.before_switch_actions)
  return before_switch_actions_;
}

// repeated .fsmproto.Action after_switch_actions = 6;
inline int Transition::_internal_after_switch_actions_size() const {
  return after_switch_actions_.size();
}
inline int Transition::after_switch_actions_size() const {
  return _internal_after_switch_actions_size();
}
inline void Transition::clear_after_switch_actions() {
  after_switch_actions_.Clear();
}
inline ::fsmproto::Action* Transition::mutable_after_switch_actions(int index) {
  // @@protoc_insertion_point(field_mutable:fsmproto.Transition.after_switch_actions)
  return after_switch_actions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >*
Transition::mutable_after_switch_actions() {
  // @@protoc_insertion_point(field_mutable_list:fsmproto.Transition.after_switch_actions)
  return &after_switch_actions_;
}
inline const ::fsmproto::Action& Transition::_internal_after_switch_actions(int index) const {
  return after_switch_actions_.Get(index);
}
inline const ::fsmproto::Action& Transition::after_switch_actions(int index) const {
  // @@protoc_insertion_point(field_get:fsmproto.Transition.after_switch_actions)
  return _internal_after_switch_actions(index);
}
inline ::fsmproto::Action* Transition::_internal_add_after_switch_actions() {
  return after_switch_actions_.Add();
}
inline ::fsmproto::Action* Transition::add_after_switch_actions() {
  // @@protoc_insertion_point(field_add:fsmproto.Transition.after_switch_actions)
  return _internal_add_after_switch_actions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >&
Transition::after_switch_actions() const {
  // @@protoc_insertion_point(field_list:fsmproto.Transition.after_switch_actions)
  return after_switch_actions_;
}

// -------------------------------------------------------------------

// State

// string name = 1;
inline void State::clear_name() {
  name_.ClearToEmpty();
}
inline const std::string& State::name() const {
  // @@protoc_insertion_point(field_get:fsmproto.State.name)
  return _internal_name();
}
inline void State::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:fsmproto.State.name)
}
inline std::string* State::mutable_name() {
  // @@protoc_insertion_point(field_mutable:fsmproto.State.name)
  return _internal_mutable_name();
}
inline const std::string& State::_internal_name() const {
  return name_.Get();
}
inline void State::_internal_set_name(const std::string& value) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void State::set_name(std::string&& value) {
  
  name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.State.name)
}
inline void State::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.State.name)
}
inline void State::set_name(const char* value,
    size_t size) {
  
  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.State.name)
}
inline std::string* State::_internal_mutable_name() {
  
  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* State::release_name() {
  // @@protoc_insertion_point(field_release:fsmproto.State.name)
  return name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void State::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.State.name)
}

// repeated .fsmproto.Action entry = 2;
inline int State::_internal_entry_size() const {
  return entry_.size();
}
inline int State::entry_size() const {
  return _internal_entry_size();
}
inline void State::clear_entry() {
  entry_.Clear();
}
inline ::fsmproto::Action* State::mutable_entry(int index) {
  // @@protoc_insertion_point(field_mutable:fsmproto.State.entry)
  return entry_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >*
State::mutable_entry() {
  // @@protoc_insertion_point(field_mutable_list:fsmproto.State.entry)
  return &entry_;
}
inline const ::fsmproto::Action& State::_internal_entry(int index) const {
  return entry_.Get(index);
}
inline const ::fsmproto::Action& State::entry(int index) const {
  // @@protoc_insertion_point(field_get:fsmproto.State.entry)
  return _internal_entry(index);
}
inline ::fsmproto::Action* State::_internal_add_entry() {
  return entry_.Add();
}
inline ::fsmproto::Action* State::add_entry() {
  // @@protoc_insertion_point(field_add:fsmproto.State.entry)
  return _internal_add_entry();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >&
State::entry() const {
  // @@protoc_insertion_point(field_list:fsmproto.State.entry)
  return entry_;
}

// repeated .fsmproto.Action idle = 3;
inline int State::_internal_idle_size() const {
  return idle_.size();
}
inline int State::idle_size() const {
  return _internal_idle_size();
}
inline void State::clear_idle() {
  idle_.Clear();
}
inline ::fsmproto::Action* State::mutable_idle(int index) {
  // @@protoc_insertion_point(field_mutable:fsmproto.State.idle)
  return idle_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >*
State::mutable_idle() {
  // @@protoc_insertion_point(field_mutable_list:fsmproto.State.idle)
  return &idle_;
}
inline const ::fsmproto::Action& State::_internal_idle(int index) const {
  return idle_.Get(index);
}
inline const ::fsmproto::Action& State::idle(int index) const {
  // @@protoc_insertion_point(field_get:fsmproto.State.idle)
  return _internal_idle(index);
}
inline ::fsmproto::Action* State::_internal_add_idle() {
  return idle_.Add();
}
inline ::fsmproto::Action* State::add_idle() {
  // @@protoc_insertion_point(field_add:fsmproto.State.idle)
  return _internal_add_idle();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >&
State::idle() const {
  // @@protoc_insertion_point(field_list:fsmproto.State.idle)
  return idle_;
}

// repeated .fsmproto.Action exit = 4;
inline int State::_internal_exit_size() const {
  return exit_.size();
}
inline int State::exit_size() const {
  return _internal_exit_size();
}
inline void State::clear_exit() {
  exit_.Clear();
}
inline ::fsmproto::Action* State::mutable_exit(int index) {
  // @@protoc_insertion_point(field_mutable:fsmproto.State.exit)
  return exit_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >*
State::mutable_exit() {
  // @@protoc_insertion_point(field_mutable_list:fsmproto.State.exit)
  return &exit_;
}
inline const ::fsmproto::Action& State::_internal_exit(int index) const {
  return exit_.Get(index);
}
inline const ::fsmproto::Action& State::exit(int index) const {
  // @@protoc_insertion_point(field_get:fsmproto.State.exit)
  return _internal_exit(index);
}
inline ::fsmproto::Action* State::_internal_add_exit() {
  return exit_.Add();
}
inline ::fsmproto::Action* State::add_exit() {
  // @@protoc_insertion_point(field_add:fsmproto.State.exit)
  return _internal_add_exit();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Action >&
State::exit() const {
  // @@protoc_insertion_point(field_list:fsmproto.State.exit)
  return exit_;
}

// string fsm_name = 5;
inline void State::clear_fsm_name() {
  fsm_name_.ClearToEmpty();
}
inline const std::string& State::fsm_name() const {
  // @@protoc_insertion_point(field_get:fsmproto.State.fsm_name)
  return _internal_fsm_name();
}
inline void State::set_fsm_name(const std::string& value) {
  _internal_set_fsm_name(value);
  // @@protoc_insertion_point(field_set:fsmproto.State.fsm_name)
}
inline std::string* State::mutable_fsm_name() {
  // @@protoc_insertion_point(field_mutable:fsmproto.State.fsm_name)
  return _internal_mutable_fsm_name();
}
inline const std::string& State::_internal_fsm_name() const {
  return fsm_name_.Get();
}
inline void State::_internal_set_fsm_name(const std::string& value) {
  
  fsm_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void State::set_fsm_name(std::string&& value) {
  
  fsm_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.State.fsm_name)
}
inline void State::set_fsm_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  fsm_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.State.fsm_name)
}
inline void State::set_fsm_name(const char* value,
    size_t size) {
  
  fsm_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.State.fsm_name)
}
inline std::string* State::_internal_mutable_fsm_name() {
  
  return fsm_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* State::release_fsm_name() {
  // @@protoc_insertion_point(field_release:fsmproto.State.fsm_name)
  return fsm_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void State::set_allocated_fsm_name(std::string* fsm_name) {
  if (fsm_name != nullptr) {
    
  } else {
    
  }
  fsm_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), fsm_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.State.fsm_name)
}

// string state_delegate_key = 6;
inline void State::clear_state_delegate_key() {
  state_delegate_key_.ClearToEmpty();
}
inline const std::string& State::state_delegate_key() const {
  // @@protoc_insertion_point(field_get:fsmproto.State.state_delegate_key)
  return _internal_state_delegate_key();
}
inline void State::set_state_delegate_key(const std::string& value) {
  _internal_set_state_delegate_key(value);
  // @@protoc_insertion_point(field_set:fsmproto.State.state_delegate_key)
}
inline std::string* State::mutable_state_delegate_key() {
  // @@protoc_insertion_point(field_mutable:fsmproto.State.state_delegate_key)
  return _internal_mutable_state_delegate_key();
}
inline const std::string& State::_internal_state_delegate_key() const {
  return state_delegate_key_.Get();
}
inline void State::_internal_set_state_delegate_key(const std::string& value) {
  
  state_delegate_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void State::set_state_delegate_key(std::string&& value) {
  
  state_delegate_key_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.State.state_delegate_key)
}
inline void State::set_state_delegate_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  state_delegate_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.State.state_delegate_key)
}
inline void State::set_state_delegate_key(const char* value,
    size_t size) {
  
  state_delegate_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.State.state_delegate_key)
}
inline std::string* State::_internal_mutable_state_delegate_key() {
  
  return state_delegate_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* State::release_state_delegate_key() {
  // @@protoc_insertion_point(field_release:fsmproto.State.state_delegate_key)
  return state_delegate_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void State::set_allocated_state_delegate_key(std::string* state_delegate_key) {
  if (state_delegate_key != nullptr) {
    
  } else {
    
  }
  state_delegate_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), state_delegate_key,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.State.state_delegate_key)
}

// -------------------------------------------------------------------

// Param

// string type = 1;
inline void Param::clear_type() {
  type_.ClearToEmpty();
}
inline const std::string& Param::type() const {
  // @@protoc_insertion_point(field_get:fsmproto.Param.type)
  return _internal_type();
}
inline void Param::set_type(const std::string& value) {
  _internal_set_type(value);
  // @@protoc_insertion_point(field_set:fsmproto.Param.type)
}
inline std::string* Param::mutable_type() {
  // @@protoc_insertion_point(field_mutable:fsmproto.Param.type)
  return _internal_mutable_type();
}
inline const std::string& Param::_internal_type() const {
  return type_.Get();
}
inline void Param::_internal_set_type(const std::string& value) {
  
  type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Param::set_type(std::string&& value) {
  
  type_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.Param.type)
}
inline void Param::set_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.Param.type)
}
inline void Param::set_type(const char* value,
    size_t size) {
  
  type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.Param.type)
}
inline std::string* Param::_internal_mutable_type() {
  
  return type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Param::release_type() {
  // @@protoc_insertion_point(field_release:fsmproto.Param.type)
  return type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Param::set_allocated_type(std::string* type) {
  if (type != nullptr) {
    
  } else {
    
  }
  type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.Param.type)
}

// string default_value = 2;
inline void Param::clear_default_value() {
  default_value_.ClearToEmpty();
}
inline const std::string& Param::default_value() const {
  // @@protoc_insertion_point(field_get:fsmproto.Param.default_value)
  return _internal_default_value();
}
inline void Param::set_default_value(const std::string& value) {
  _internal_set_default_value(value);
  // @@protoc_insertion_point(field_set:fsmproto.Param.default_value)
}
inline std::string* Param::mutable_default_value() {
  // @@protoc_insertion_point(field_mutable:fsmproto.Param.default_value)
  return _internal_mutable_default_value();
}
inline const std::string& Param::_internal_default_value() const {
  return default_value_.Get();
}
inline void Param::_internal_set_default_value(const std::string& value) {
  
  default_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void Param::set_default_value(std::string&& value) {
  
  default_value_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.Param.default_value)
}
inline void Param::set_default_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  default_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.Param.default_value)
}
inline void Param::set_default_value(const char* value,
    size_t size) {
  
  default_value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.Param.default_value)
}
inline std::string* Param::_internal_mutable_default_value() {
  
  return default_value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* Param::release_default_value() {
  // @@protoc_insertion_point(field_release:fsmproto.Param.default_value)
  return default_value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void Param::set_allocated_default_value(std::string* default_value) {
  if (default_value != nullptr) {
    
  } else {
    
  }
  default_value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), default_value,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.Param.default_value)
}

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// StateMachine

// string init_state_name = 1;
inline void StateMachine::clear_init_state_name() {
  init_state_name_.ClearToEmpty();
}
inline const std::string& StateMachine::init_state_name() const {
  // @@protoc_insertion_point(field_get:fsmproto.StateMachine.init_state_name)
  return _internal_init_state_name();
}
inline void StateMachine::set_init_state_name(const std::string& value) {
  _internal_set_init_state_name(value);
  // @@protoc_insertion_point(field_set:fsmproto.StateMachine.init_state_name)
}
inline std::string* StateMachine::mutable_init_state_name() {
  // @@protoc_insertion_point(field_mutable:fsmproto.StateMachine.init_state_name)
  return _internal_mutable_init_state_name();
}
inline const std::string& StateMachine::_internal_init_state_name() const {
  return init_state_name_.Get();
}
inline void StateMachine::_internal_set_init_state_name(const std::string& value) {
  
  init_state_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void StateMachine::set_init_state_name(std::string&& value) {
  
  init_state_name_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.StateMachine.init_state_name)
}
inline void StateMachine::set_init_state_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  init_state_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.StateMachine.init_state_name)
}
inline void StateMachine::set_init_state_name(const char* value,
    size_t size) {
  
  init_state_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.StateMachine.init_state_name)
}
inline std::string* StateMachine::_internal_mutable_init_state_name() {
  
  return init_state_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* StateMachine::release_init_state_name() {
  // @@protoc_insertion_point(field_release:fsmproto.StateMachine.init_state_name)
  return init_state_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void StateMachine::set_allocated_init_state_name(std::string* init_state_name) {
  if (init_state_name != nullptr) {
    
  } else {
    
  }
  init_state_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), init_state_name,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.StateMachine.init_state_name)
}

// string machine_type = 2;
inline void StateMachine::clear_machine_type() {
  machine_type_.ClearToEmpty();
}
inline const std::string& StateMachine::machine_type() const {
  // @@protoc_insertion_point(field_get:fsmproto.StateMachine.machine_type)
  return _internal_machine_type();
}
inline void StateMachine::set_machine_type(const std::string& value) {
  _internal_set_machine_type(value);
  // @@protoc_insertion_point(field_set:fsmproto.StateMachine.machine_type)
}
inline std::string* StateMachine::mutable_machine_type() {
  // @@protoc_insertion_point(field_mutable:fsmproto.StateMachine.machine_type)
  return _internal_mutable_machine_type();
}
inline const std::string& StateMachine::_internal_machine_type() const {
  return machine_type_.Get();
}
inline void StateMachine::_internal_set_machine_type(const std::string& value) {
  
  machine_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena());
}
inline void StateMachine::set_machine_type(std::string&& value) {
  
  machine_type_.Set(
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:fsmproto.StateMachine.machine_type)
}
inline void StateMachine::set_machine_type(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  machine_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:fsmproto.StateMachine.machine_type)
}
inline void StateMachine::set_machine_type(const char* value,
    size_t size) {
  
  machine_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:fsmproto.StateMachine.machine_type)
}
inline std::string* StateMachine::_internal_mutable_machine_type() {
  
  return machine_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena());
}
inline std::string* StateMachine::release_machine_type() {
  // @@protoc_insertion_point(field_release:fsmproto.StateMachine.machine_type)
  return machine_type_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void StateMachine::set_allocated_machine_type(std::string* machine_type) {
  if (machine_type != nullptr) {
    
  } else {
    
  }
  machine_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), machine_type,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:fsmproto.StateMachine.machine_type)
}

// map<string, .fsmproto.Param> params = 3;
inline int StateMachine::_internal_params_size() const {
  return params_.size();
}
inline int StateMachine::params_size() const {
  return _internal_params_size();
}
inline void StateMachine::clear_params() {
  params_.Clear();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >&
StateMachine::_internal_params() const {
  return params_.GetMap();
}
inline const ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >&
StateMachine::params() const {
  // @@protoc_insertion_point(field_map:fsmproto.StateMachine.params)
  return _internal_params();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >*
StateMachine::_internal_mutable_params() {
  return params_.MutableMap();
}
inline ::PROTOBUF_NAMESPACE_ID::Map< std::string, ::fsmproto::Param >*
StateMachine::mutable_params() {
  // @@protoc_insertion_point(field_mutable_map:fsmproto.StateMachine.params)
  return _internal_mutable_params();
}

// repeated .fsmproto.State states = 4;
inline int StateMachine::_internal_states_size() const {
  return states_.size();
}
inline int StateMachine::states_size() const {
  return _internal_states_size();
}
inline void StateMachine::clear_states() {
  states_.Clear();
}
inline ::fsmproto::State* StateMachine::mutable_states(int index) {
  // @@protoc_insertion_point(field_mutable:fsmproto.StateMachine.states)
  return states_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::State >*
StateMachine::mutable_states() {
  // @@protoc_insertion_point(field_mutable_list:fsmproto.StateMachine.states)
  return &states_;
}
inline const ::fsmproto::State& StateMachine::_internal_states(int index) const {
  return states_.Get(index);
}
inline const ::fsmproto::State& StateMachine::states(int index) const {
  // @@protoc_insertion_point(field_get:fsmproto.StateMachine.states)
  return _internal_states(index);
}
inline ::fsmproto::State* StateMachine::_internal_add_states() {
  return states_.Add();
}
inline ::fsmproto::State* StateMachine::add_states() {
  // @@protoc_insertion_point(field_add:fsmproto.StateMachine.states)
  return _internal_add_states();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::State >&
StateMachine::states() const {
  // @@protoc_insertion_point(field_list:fsmproto.StateMachine.states)
  return states_;
}

// repeated .fsmproto.Transition transitions = 5;
inline int StateMachine::_internal_transitions_size() const {
  return transitions_.size();
}
inline int StateMachine::transitions_size() const {
  return _internal_transitions_size();
}
inline void StateMachine::clear_transitions() {
  transitions_.Clear();
}
inline ::fsmproto::Transition* StateMachine::mutable_transitions(int index) {
  // @@protoc_insertion_point(field_mutable:fsmproto.StateMachine.transitions)
  return transitions_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Transition >*
StateMachine::mutable_transitions() {
  // @@protoc_insertion_point(field_mutable_list:fsmproto.StateMachine.transitions)
  return &transitions_;
}
inline const ::fsmproto::Transition& StateMachine::_internal_transitions(int index) const {
  return transitions_.Get(index);
}
inline const ::fsmproto::Transition& StateMachine::transitions(int index) const {
  // @@protoc_insertion_point(field_get:fsmproto.StateMachine.transitions)
  return _internal_transitions(index);
}
inline ::fsmproto::Transition* StateMachine::_internal_add_transitions() {
  return transitions_.Add();
}
inline ::fsmproto::Transition* StateMachine::add_transitions() {
  // @@protoc_insertion_point(field_add:fsmproto.StateMachine.transitions)
  return _internal_add_transitions();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::fsmproto::Transition >&
StateMachine::transitions() const {
  // @@protoc_insertion_point(field_list:fsmproto.StateMachine.transitions)
  return transitions_;
}

#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------

// -------------------------------------------------------------------


// @@protoc_insertion_point(namespace_scope)

}  // namespace fsmproto

// @@protoc_insertion_point(global_scope)

#include <google/protobuf/port_undef.inc>
#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_state_5fmachine_5fconfig_2eproto