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

#ifndef GOOGLE_PROTOBUF_INCLUDED_sync_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_sync_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3012000
#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 3012004 < 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/inlined_string_field.h>
#include <google/protobuf/metadata_lite.h>
#include <google/protobuf/generated_message_reflection.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
#include <google/protobuf/extension_set.h>  // IWYU pragma: export
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_sync_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_sync_2eproto {
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxillaryParseTableField aux[]
    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[8]
    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[];
};
extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_sync_2eproto;
namespace sync_proto {
class Config;
class ConfigDefaultTypeInternal;
extern ConfigDefaultTypeInternal _Config_default_instance_;
class ConfigItem;
class ConfigItemDefaultTypeInternal;
extern ConfigItemDefaultTypeInternal _ConfigItem_default_instance_;
class Envelope;
class EnvelopeDefaultTypeInternal;
extern EnvelopeDefaultTypeInternal _Envelope_default_instance_;
class GPS_RAW;
class GPS_RAWDefaultTypeInternal;
extern GPS_RAWDefaultTypeInternal _GPS_RAW_default_instance_;
class IMU;
class IMUDefaultTypeInternal;
extern IMUDefaultTypeInternal _IMU_default_instance_;
class IMU_RAW;
class IMU_RAWDefaultTypeInternal;
extern IMU_RAWDefaultTypeInternal _IMU_RAW_default_instance_;
class LOG;
class LOGDefaultTypeInternal;
extern LOGDefaultTypeInternal _LOG_default_instance_;
class TRIGGER;
class TRIGGERDefaultTypeInternal;
extern TRIGGERDefaultTypeInternal _TRIGGER_default_instance_;
}  // namespace sync_proto
PROTOBUF_NAMESPACE_OPEN
template<> ::sync_proto::Config* Arena::CreateMaybeMessage<::sync_proto::Config>(Arena*);
template<> ::sync_proto::ConfigItem* Arena::CreateMaybeMessage<::sync_proto::ConfigItem>(Arena*);
template<> ::sync_proto::Envelope* Arena::CreateMaybeMessage<::sync_proto::Envelope>(Arena*);
template<> ::sync_proto::GPS_RAW* Arena::CreateMaybeMessage<::sync_proto::GPS_RAW>(Arena*);
template<> ::sync_proto::IMU* Arena::CreateMaybeMessage<::sync_proto::IMU>(Arena*);
template<> ::sync_proto::IMU_RAW* Arena::CreateMaybeMessage<::sync_proto::IMU_RAW>(Arena*);
template<> ::sync_proto::LOG* Arena::CreateMaybeMessage<::sync_proto::LOG>(Arena*);
template<> ::sync_proto::TRIGGER* Arena::CreateMaybeMessage<::sync_proto::TRIGGER>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace sync_proto {

enum MessageID : int {
  MSG_UNKNOWN = 0,
  MSG_IMU_RAW = 1,
  MSG_IMU = 2,
  MSG_SYSTEM_TIME = 3,
  MSG_TRIGGER = 4,
  MSG_LOG = 5,
  MSG_GPS_RAW = 6,
  MSG_CONFIG = 7,
  MessageID_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  MessageID_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool MessageID_IsValid(int value);
constexpr MessageID MessageID_MIN = MSG_UNKNOWN;
constexpr MessageID MessageID_MAX = MSG_CONFIG;
constexpr int MessageID_ARRAYSIZE = MessageID_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MessageID_descriptor();
template<typename T>
inline const std::string& MessageID_Name(T enum_t_value) {
  static_assert(::std::is_same<T, MessageID>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function MessageID_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    MessageID_descriptor(), enum_t_value);
}
inline bool MessageID_Parse(
    const std::string& name, MessageID* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MessageID>(
    MessageID_descriptor(), name, value);
}
enum CfgPropID : int {
  CFG_BOOL_UNKNOWN = 0,
  CFG_BOOL_DEBUG_MODE = 1,
  CFG_INT_TRIGGER_FREQ = 2,
  CFG_BOOL_TRIGGER_EDGE = 3,
  CFG_BOOL_TRIGGER_ONCE = 4,
  CfgPropID_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  CfgPropID_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool CfgPropID_IsValid(int value);
constexpr CfgPropID CfgPropID_MIN = CFG_BOOL_UNKNOWN;
constexpr CfgPropID CfgPropID_MAX = CFG_BOOL_TRIGGER_ONCE;
constexpr int CfgPropID_ARRAYSIZE = CfgPropID_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CfgPropID_descriptor();
template<typename T>
inline const std::string& CfgPropID_Name(T enum_t_value) {
  static_assert(::std::is_same<T, CfgPropID>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function CfgPropID_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    CfgPropID_descriptor(), enum_t_value);
}
inline bool CfgPropID_Parse(
    const std::string& name, CfgPropID* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CfgPropID>(
    CfgPropID_descriptor(), name, value);
}
enum LogLevel : int {
  INFO = 0,
  WARN = 1,
  ERROR = 2,
  DEBUG = 3,
  LogLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  LogLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool LogLevel_IsValid(int value);
constexpr LogLevel LogLevel_MIN = INFO;
constexpr LogLevel LogLevel_MAX = DEBUG;
constexpr int LogLevel_ARRAYSIZE = LogLevel_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LogLevel_descriptor();
template<typename T>
inline const std::string& LogLevel_Name(T enum_t_value) {
  static_assert(::std::is_same<T, LogLevel>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function LogLevel_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    LogLevel_descriptor(), enum_t_value);
}
inline bool LogLevel_Parse(
    const std::string& name, LogLevel* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LogLevel>(
    LogLevel_descriptor(), name, value);
}
enum GPSSatStatus : int {
  GPS_UNKNOWN = 0,
  GPS_FIX_NONE = 1,
  GPS_FIX_2D = 2,
  GPS_FIX_3D = 3,
  GPSSatStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
  GPSSatStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
};
bool GPSSatStatus_IsValid(int value);
constexpr GPSSatStatus GPSSatStatus_MIN = GPS_UNKNOWN;
constexpr GPSSatStatus GPSSatStatus_MAX = GPS_FIX_3D;
constexpr int GPSSatStatus_ARRAYSIZE = GPSSatStatus_MAX + 1;

const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* GPSSatStatus_descriptor();
template<typename T>
inline const std::string& GPSSatStatus_Name(T enum_t_value) {
  static_assert(::std::is_same<T, GPSSatStatus>::value ||
    ::std::is_integral<T>::value,
    "Incorrect type passed to function GPSSatStatus_Name.");
  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
    GPSSatStatus_descriptor(), enum_t_value);
}
inline bool GPSSatStatus_Parse(
    const std::string& name, GPSSatStatus* value) {
  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<GPSSatStatus>(
    GPSSatStatus_descriptor(), name, value);
}
// ===================================================================

class ConfigItem PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:sync_proto.ConfigItem) */ {
 public:
  inline ConfigItem() : ConfigItem(nullptr) {};
  virtual ~ConfigItem();

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const ConfigItem& default_instance();

  enum ValueCase {
    kBoolValue = 2,
    kIntValue = 3,
    kFloatValue = 4,
    kStrValue = 5,
    VALUE_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const ConfigItem* internal_default_instance() {
    return reinterpret_cast<const ConfigItem*>(
               &_ConfigItem_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    0;

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

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

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

  ConfigItem* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ConfigItem>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ConfigItem& from);
  void MergeFrom(const ConfigItem& 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;
  int GetCachedSize() const final { return _cached_size_.Get(); }

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

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_sync_2eproto);
    return ::descriptor_table_sync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPropIdFieldNumber = 1,
    kBoolValueFieldNumber = 2,
    kIntValueFieldNumber = 3,
    kFloatValueFieldNumber = 4,
    kStrValueFieldNumber = 5,
  };
  // .sync_proto.CfgPropID prop_id = 1;
  void clear_prop_id();
  ::sync_proto::CfgPropID prop_id() const;
  void set_prop_id(::sync_proto::CfgPropID value);
  private:
  ::sync_proto::CfgPropID _internal_prop_id() const;
  void _internal_set_prop_id(::sync_proto::CfgPropID value);
  public:

  // bool bool_value = 2;
  private:
  bool _internal_has_bool_value() const;
  public:
  void clear_bool_value();
  bool bool_value() const;
  void set_bool_value(bool value);
  private:
  bool _internal_bool_value() const;
  void _internal_set_bool_value(bool value);
  public:

  // int32 int_value = 3;
  private:
  bool _internal_has_int_value() const;
  public:
  void clear_int_value();
  ::PROTOBUF_NAMESPACE_ID::int32 int_value() const;
  void set_int_value(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_int_value() const;
  void _internal_set_int_value(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // float float_value = 4;
  private:
  bool _internal_has_float_value() const;
  public:
  void clear_float_value();
  float float_value() const;
  void set_float_value(float value);
  private:
  float _internal_float_value() const;
  void _internal_set_float_value(float value);
  public:

  // string str_value = 5;
  private:
  bool _internal_has_str_value() const;
  public:
  void clear_str_value();
  const std::string& str_value() const;
  void set_str_value(const std::string& value);
  void set_str_value(std::string&& value);
  void set_str_value(const char* value);
  void set_str_value(const char* value, size_t size);
  std::string* mutable_str_value();
  std::string* release_str_value();
  void set_allocated_str_value(std::string* str_value);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_str_value();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_str_value(
      std::string* str_value);
  private:
  const std::string& _internal_str_value() const;
  void _internal_set_str_value(const std::string& value);
  std::string* _internal_mutable_str_value();
  public:

  void clear_value();
  ValueCase value_case() const;
  // @@protoc_insertion_point(class_scope:sync_proto.ConfigItem)
 private:
  class _Internal;
  void set_has_bool_value();
  void set_has_int_value();
  void set_has_float_value();
  void set_has_str_value();

  inline bool has_value() const;
  inline void clear_has_value();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int prop_id_;
  union ValueUnion {
    ValueUnion() {}
    bool bool_value_;
    ::PROTOBUF_NAMESPACE_ID::int32 int_value_;
    float float_value_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr str_value_;
  } value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_sync_2eproto;
};
// -------------------------------------------------------------------

class Config PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:sync_proto.Config) */ {
 public:
  inline Config() : Config(nullptr) {};
  virtual ~Config();

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Config& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Config* internal_default_instance() {
    return reinterpret_cast<const Config*>(
               &_Config_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    1;

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

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

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

  Config* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Config>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Config& from);
  void MergeFrom(const Config& 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;
  int GetCachedSize() const final { return _cached_size_.Get(); }

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

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_sync_2eproto);
    return ::descriptor_table_sync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kItemFieldNumber = 1,
  };
  // repeated .sync_proto.ConfigItem item = 1;
  int item_size() const;
  private:
  int _internal_item_size() const;
  public:
  void clear_item();
  ::sync_proto::ConfigItem* mutable_item(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::sync_proto::ConfigItem >*
      mutable_item();
  private:
  const ::sync_proto::ConfigItem& _internal_item(int index) const;
  ::sync_proto::ConfigItem* _internal_add_item();
  public:
  const ::sync_proto::ConfigItem& item(int index) const;
  ::sync_proto::ConfigItem* add_item();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::sync_proto::ConfigItem >&
      item() const;

  // @@protoc_insertion_point(class_scope:sync_proto.Config)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::sync_proto::ConfigItem > item_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sync_2eproto;
};
// -------------------------------------------------------------------

class IMU_RAW PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:sync_proto.IMU_RAW) */ {
 public:
  inline IMU_RAW() : IMU_RAW(nullptr) {};
  virtual ~IMU_RAW();

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const IMU_RAW& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const IMU_RAW* internal_default_instance() {
    return reinterpret_cast<const IMU_RAW*>(
               &_IMU_RAW_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    2;

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

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

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

  IMU_RAW* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IMU_RAW>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IMU_RAW& from);
  void MergeFrom(const IMU_RAW& 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;
  int GetCachedSize() const final { return _cached_size_.Get(); }

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

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_sync_2eproto);
    return ::descriptor_table_sync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTimeUsFieldNumber = 1,
    kAxFieldNumber = 2,
    kAyFieldNumber = 3,
    kAzFieldNumber = 4,
    kGxFieldNumber = 5,
    kGyFieldNumber = 6,
    kGzFieldNumber = 7,
  };
  // int64 time_us = 1;
  void clear_time_us();
  ::PROTOBUF_NAMESPACE_ID::int64 time_us() const;
  void set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_time_us() const;
  void _internal_set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // double ax = 2;
  void clear_ax();
  double ax() const;
  void set_ax(double value);
  private:
  double _internal_ax() const;
  void _internal_set_ax(double value);
  public:

  // double ay = 3;
  void clear_ay();
  double ay() const;
  void set_ay(double value);
  private:
  double _internal_ay() const;
  void _internal_set_ay(double value);
  public:

  // double az = 4;
  void clear_az();
  double az() const;
  void set_az(double value);
  private:
  double _internal_az() const;
  void _internal_set_az(double value);
  public:

  // double gx = 5;
  void clear_gx();
  double gx() const;
  void set_gx(double value);
  private:
  double _internal_gx() const;
  void _internal_set_gx(double value);
  public:

  // double gy = 6;
  void clear_gy();
  double gy() const;
  void set_gy(double value);
  private:
  double _internal_gy() const;
  void _internal_set_gy(double value);
  public:

  // double gz = 7;
  void clear_gz();
  double gz() const;
  void set_gz(double value);
  private:
  double _internal_gz() const;
  void _internal_set_gz(double value);
  public:

  // @@protoc_insertion_point(class_scope:sync_proto.IMU_RAW)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 time_us_;
  double ax_;
  double ay_;
  double az_;
  double gx_;
  double gy_;
  double gz_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sync_2eproto;
};
// -------------------------------------------------------------------

class IMU PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:sync_proto.IMU) */ {
 public:
  inline IMU() : IMU(nullptr) {};
  virtual ~IMU();

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const IMU& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const IMU* internal_default_instance() {
    return reinterpret_cast<const IMU*>(
               &_IMU_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    3;

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

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

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

  IMU* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IMU>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IMU& from);
  void MergeFrom(const IMU& 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;
  int GetCachedSize() const final { return _cached_size_.Get(); }

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

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_sync_2eproto);
    return ::descriptor_table_sync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTimeUsFieldNumber = 1,
    kAxFieldNumber = 2,
    kAyFieldNumber = 3,
    kAzFieldNumber = 4,
    kGxFieldNumber = 5,
    kGyFieldNumber = 6,
    kGzFieldNumber = 7,
    kRollFieldNumber = 8,
    kPitchFieldNumber = 9,
    kYawFieldNumber = 10,
  };
  // int64 time_us = 1;
  void clear_time_us();
  ::PROTOBUF_NAMESPACE_ID::int64 time_us() const;
  void set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_time_us() const;
  void _internal_set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // double ax = 2;
  void clear_ax();
  double ax() const;
  void set_ax(double value);
  private:
  double _internal_ax() const;
  void _internal_set_ax(double value);
  public:

  // double ay = 3;
  void clear_ay();
  double ay() const;
  void set_ay(double value);
  private:
  double _internal_ay() const;
  void _internal_set_ay(double value);
  public:

  // double az = 4;
  void clear_az();
  double az() const;
  void set_az(double value);
  private:
  double _internal_az() const;
  void _internal_set_az(double value);
  public:

  // double gx = 5;
  void clear_gx();
  double gx() const;
  void set_gx(double value);
  private:
  double _internal_gx() const;
  void _internal_set_gx(double value);
  public:

  // double gy = 6;
  void clear_gy();
  double gy() const;
  void set_gy(double value);
  private:
  double _internal_gy() const;
  void _internal_set_gy(double value);
  public:

  // double gz = 7;
  void clear_gz();
  double gz() const;
  void set_gz(double value);
  private:
  double _internal_gz() const;
  void _internal_set_gz(double value);
  public:

  // double roll = 8;
  void clear_roll();
  double roll() const;
  void set_roll(double value);
  private:
  double _internal_roll() const;
  void _internal_set_roll(double value);
  public:

  // double pitch = 9;
  void clear_pitch();
  double pitch() const;
  void set_pitch(double value);
  private:
  double _internal_pitch() const;
  void _internal_set_pitch(double value);
  public:

  // double yaw = 10;
  void clear_yaw();
  double yaw() const;
  void set_yaw(double value);
  private:
  double _internal_yaw() const;
  void _internal_set_yaw(double value);
  public:

  // @@protoc_insertion_point(class_scope:sync_proto.IMU)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 time_us_;
  double ax_;
  double ay_;
  double az_;
  double gx_;
  double gy_;
  double gz_;
  double roll_;
  double pitch_;
  double yaw_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sync_2eproto;
};
// -------------------------------------------------------------------

class TRIGGER PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:sync_proto.TRIGGER) */ {
 public:
  inline TRIGGER() : TRIGGER(nullptr) {};
  virtual ~TRIGGER();

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const TRIGGER& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const TRIGGER* internal_default_instance() {
    return reinterpret_cast<const TRIGGER*>(
               &_TRIGGER_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    4;

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

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

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

  TRIGGER* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<TRIGGER>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const TRIGGER& from);
  void MergeFrom(const TRIGGER& 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;
  int GetCachedSize() const final { return _cached_size_.Get(); }

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

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_sync_2eproto);
    return ::descriptor_table_sync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTriggerTimeUsFieldNumber = 1,
    kRecvTriggerTimeUsFieldNumber = 2,
  };
  // int64 trigger_time_us = 1;
  void clear_trigger_time_us();
  ::PROTOBUF_NAMESPACE_ID::int64 trigger_time_us() const;
  void set_trigger_time_us(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_trigger_time_us() const;
  void _internal_set_trigger_time_us(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // int64 recv_trigger_time_us = 2;
  void clear_recv_trigger_time_us();
  ::PROTOBUF_NAMESPACE_ID::int64 recv_trigger_time_us() const;
  void set_recv_trigger_time_us(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_recv_trigger_time_us() const;
  void _internal_set_recv_trigger_time_us(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:sync_proto.TRIGGER)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 trigger_time_us_;
  ::PROTOBUF_NAMESPACE_ID::int64 recv_trigger_time_us_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sync_2eproto;
};
// -------------------------------------------------------------------

class LOG PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:sync_proto.LOG) */ {
 public:
  inline LOG() : LOG(nullptr) {};
  virtual ~LOG();

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const LOG& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const LOG* internal_default_instance() {
    return reinterpret_cast<const LOG*>(
               &_LOG_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    5;

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

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

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

  LOG* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<LOG>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const LOG& from);
  void MergeFrom(const LOG& 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;
  int GetCachedSize() const final { return _cached_size_.Get(); }

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

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_sync_2eproto);
    return ::descriptor_table_sync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kLevelFieldNumber = 2,
    kModuleFieldNumber = 3,
    kMessageFieldNumber = 4,
    kTimeFieldNumber = 1,
  };
  // string level = 2;
  void clear_level();
  const std::string& level() const;
  void set_level(const std::string& value);
  void set_level(std::string&& value);
  void set_level(const char* value);
  void set_level(const char* value, size_t size);
  std::string* mutable_level();
  std::string* release_level();
  void set_allocated_level(std::string* level);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_level();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_level(
      std::string* level);
  private:
  const std::string& _internal_level() const;
  void _internal_set_level(const std::string& value);
  std::string* _internal_mutable_level();
  public:

  // string module = 3;
  void clear_module();
  const std::string& module() const;
  void set_module(const std::string& value);
  void set_module(std::string&& value);
  void set_module(const char* value);
  void set_module(const char* value, size_t size);
  std::string* mutable_module();
  std::string* release_module();
  void set_allocated_module(std::string* module);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_module();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_module(
      std::string* module);
  private:
  const std::string& _internal_module() const;
  void _internal_set_module(const std::string& value);
  std::string* _internal_mutable_module();
  public:

  // string message = 4;
  void clear_message();
  const std::string& message() const;
  void set_message(const std::string& value);
  void set_message(std::string&& value);
  void set_message(const char* value);
  void set_message(const char* value, size_t size);
  std::string* mutable_message();
  std::string* release_message();
  void set_allocated_message(std::string* message);
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  std::string* unsafe_arena_release_message();
  GOOGLE_PROTOBUF_RUNTIME_DEPRECATED("The unsafe_arena_ accessors for"
  "    string fields are deprecated and will be removed in a"
  "    future release.")
  void unsafe_arena_set_allocated_message(
      std::string* message);
  private:
  const std::string& _internal_message() const;
  void _internal_set_message(const std::string& value);
  std::string* _internal_mutable_message();
  public:

  // int64 time = 1;
  void clear_time();
  ::PROTOBUF_NAMESPACE_ID::int64 time() const;
  void set_time(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_time() const;
  void _internal_set_time(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // @@protoc_insertion_point(class_scope:sync_proto.LOG)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr level_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr module_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
  ::PROTOBUF_NAMESPACE_ID::int64 time_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sync_2eproto;
};
// -------------------------------------------------------------------

class GPS_RAW PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:sync_proto.GPS_RAW) */ {
 public:
  inline GPS_RAW() : GPS_RAW(nullptr) {};
  virtual ~GPS_RAW();

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const GPS_RAW& default_instance();

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const GPS_RAW* internal_default_instance() {
    return reinterpret_cast<const GPS_RAW*>(
               &_GPS_RAW_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    6;

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

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

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

  GPS_RAW* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GPS_RAW>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GPS_RAW& from);
  void MergeFrom(const GPS_RAW& 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;
  int GetCachedSize() const final { return _cached_size_.Get(); }

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

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_sync_2eproto);
    return ::descriptor_table_sync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kTimeUsFieldNumber = 1,
    kLatitudeFieldNumber = 2,
    kLongitudeFieldNumber = 3,
    kAltitudeFieldNumber = 4,
    kEphFieldNumber = 5,
    kEpvFieldNumber = 6,
    kVelFieldNumber = 7,
    kCogFieldNumber = 8,
    kFixTypeFieldNumber = 9,
    kSatellitesVisibleFieldNumber = 10,
  };
  // int64 time_us = 1;
  void clear_time_us();
  ::PROTOBUF_NAMESPACE_ID::int64 time_us() const;
  void set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int64 _internal_time_us() const;
  void _internal_set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value);
  public:

  // double latitude = 2;
  void clear_latitude();
  double latitude() const;
  void set_latitude(double value);
  private:
  double _internal_latitude() const;
  void _internal_set_latitude(double value);
  public:

  // double longitude = 3;
  void clear_longitude();
  double longitude() const;
  void set_longitude(double value);
  private:
  double _internal_longitude() const;
  void _internal_set_longitude(double value);
  public:

  // float altitude = 4;
  void clear_altitude();
  float altitude() const;
  void set_altitude(float value);
  private:
  float _internal_altitude() const;
  void _internal_set_altitude(float value);
  public:

  // float eph = 5;
  void clear_eph();
  float eph() const;
  void set_eph(float value);
  private:
  float _internal_eph() const;
  void _internal_set_eph(float value);
  public:

  // float epv = 6;
  void clear_epv();
  float epv() const;
  void set_epv(float value);
  private:
  float _internal_epv() const;
  void _internal_set_epv(float value);
  public:

  // float vel = 7;
  void clear_vel();
  float vel() const;
  void set_vel(float value);
  private:
  float _internal_vel() const;
  void _internal_set_vel(float value);
  public:

  // float cog = 8;
  void clear_cog();
  float cog() const;
  void set_cog(float value);
  private:
  float _internal_cog() const;
  void _internal_set_cog(float value);
  public:

  // uint32 fix_type = 9;
  void clear_fix_type();
  ::PROTOBUF_NAMESPACE_ID::uint32 fix_type() const;
  void set_fix_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_fix_type() const;
  void _internal_set_fix_type(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // uint32 satellites_visible = 10;
  void clear_satellites_visible();
  ::PROTOBUF_NAMESPACE_ID::uint32 satellites_visible() const;
  void set_satellites_visible(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_satellites_visible() const;
  void _internal_set_satellites_visible(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // @@protoc_insertion_point(class_scope:sync_proto.GPS_RAW)
 private:
  class _Internal;

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  ::PROTOBUF_NAMESPACE_ID::int64 time_us_;
  double latitude_;
  double longitude_;
  float altitude_;
  float eph_;
  float epv_;
  float vel_;
  float cog_;
  ::PROTOBUF_NAMESPACE_ID::uint32 fix_type_;
  ::PROTOBUF_NAMESPACE_ID::uint32 satellites_visible_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_sync_2eproto;
};
// -------------------------------------------------------------------

class Envelope PROTOBUF_FINAL :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:sync_proto.Envelope) */ {
 public:
  inline Envelope() : Envelope(nullptr) {};
  virtual ~Envelope();

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

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

  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
    return GetDescriptor();
  }
  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
    return GetMetadataStatic().descriptor;
  }
  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
    return GetMetadataStatic().reflection;
  }
  static const Envelope& default_instance();

  enum PayloadCase {
    kImuRaw = 2,
    kImu = 3,
    kTrigger = 4,
    kLog = 5,
    kGpsRaw = 6,
    PAYLOAD_NOT_SET = 0,
  };

  static void InitAsDefaultInstance();  // FOR INTERNAL USE ONLY
  static inline const Envelope* internal_default_instance() {
    return reinterpret_cast<const Envelope*>(
               &_Envelope_default_instance_);
  }
  static constexpr int kIndexInFileMessages =
    7;

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

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

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

  Envelope* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<Envelope>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const Envelope& from);
  void MergeFrom(const Envelope& 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;
  int GetCachedSize() const final { return _cached_size_.Get(); }

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

  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
  private:
  static ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadataStatic() {
    ::PROTOBUF_NAMESPACE_ID::internal::AssignDescriptors(&::descriptor_table_sync_2eproto);
    return ::descriptor_table_sync_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIdFieldNumber = 1,
    kImuRawFieldNumber = 2,
    kImuFieldNumber = 3,
    kTriggerFieldNumber = 4,
    kLogFieldNumber = 5,
    kGpsRawFieldNumber = 6,
  };
  // .sync_proto.MessageID id = 1;
  void clear_id();
  ::sync_proto::MessageID id() const;
  void set_id(::sync_proto::MessageID value);
  private:
  ::sync_proto::MessageID _internal_id() const;
  void _internal_set_id(::sync_proto::MessageID value);
  public:

  // .sync_proto.IMU_RAW imu_raw = 2;
  bool has_imu_raw() const;
  private:
  bool _internal_has_imu_raw() const;
  public:
  void clear_imu_raw();
  const ::sync_proto::IMU_RAW& imu_raw() const;
  ::sync_proto::IMU_RAW* release_imu_raw();
  ::sync_proto::IMU_RAW* mutable_imu_raw();
  void set_allocated_imu_raw(::sync_proto::IMU_RAW* imu_raw);
  private:
  const ::sync_proto::IMU_RAW& _internal_imu_raw() const;
  ::sync_proto::IMU_RAW* _internal_mutable_imu_raw();
  public:
  void unsafe_arena_set_allocated_imu_raw(
      ::sync_proto::IMU_RAW* imu_raw);
  ::sync_proto::IMU_RAW* unsafe_arena_release_imu_raw();

  // .sync_proto.IMU imu = 3;
  bool has_imu() const;
  private:
  bool _internal_has_imu() const;
  public:
  void clear_imu();
  const ::sync_proto::IMU& imu() const;
  ::sync_proto::IMU* release_imu();
  ::sync_proto::IMU* mutable_imu();
  void set_allocated_imu(::sync_proto::IMU* imu);
  private:
  const ::sync_proto::IMU& _internal_imu() const;
  ::sync_proto::IMU* _internal_mutable_imu();
  public:
  void unsafe_arena_set_allocated_imu(
      ::sync_proto::IMU* imu);
  ::sync_proto::IMU* unsafe_arena_release_imu();

  // .sync_proto.TRIGGER trigger = 4;
  bool has_trigger() const;
  private:
  bool _internal_has_trigger() const;
  public:
  void clear_trigger();
  const ::sync_proto::TRIGGER& trigger() const;
  ::sync_proto::TRIGGER* release_trigger();
  ::sync_proto::TRIGGER* mutable_trigger();
  void set_allocated_trigger(::sync_proto::TRIGGER* trigger);
  private:
  const ::sync_proto::TRIGGER& _internal_trigger() const;
  ::sync_proto::TRIGGER* _internal_mutable_trigger();
  public:
  void unsafe_arena_set_allocated_trigger(
      ::sync_proto::TRIGGER* trigger);
  ::sync_proto::TRIGGER* unsafe_arena_release_trigger();

  // .sync_proto.LOG log = 5;
  bool has_log() const;
  private:
  bool _internal_has_log() const;
  public:
  void clear_log();
  const ::sync_proto::LOG& log() const;
  ::sync_proto::LOG* release_log();
  ::sync_proto::LOG* mutable_log();
  void set_allocated_log(::sync_proto::LOG* log);
  private:
  const ::sync_proto::LOG& _internal_log() const;
  ::sync_proto::LOG* _internal_mutable_log();
  public:
  void unsafe_arena_set_allocated_log(
      ::sync_proto::LOG* log);
  ::sync_proto::LOG* unsafe_arena_release_log();

  // .sync_proto.GPS_RAW gps_raw = 6;
  bool has_gps_raw() const;
  private:
  bool _internal_has_gps_raw() const;
  public:
  void clear_gps_raw();
  const ::sync_proto::GPS_RAW& gps_raw() const;
  ::sync_proto::GPS_RAW* release_gps_raw();
  ::sync_proto::GPS_RAW* mutable_gps_raw();
  void set_allocated_gps_raw(::sync_proto::GPS_RAW* gps_raw);
  private:
  const ::sync_proto::GPS_RAW& _internal_gps_raw() const;
  ::sync_proto::GPS_RAW* _internal_mutable_gps_raw();
  public:
  void unsafe_arena_set_allocated_gps_raw(
      ::sync_proto::GPS_RAW* gps_raw);
  ::sync_proto::GPS_RAW* unsafe_arena_release_gps_raw();

  void clear_payload();
  PayloadCase payload_case() const;
  // @@protoc_insertion_point(class_scope:sync_proto.Envelope)
 private:
  class _Internal;
  void set_has_imu_raw();
  void set_has_imu();
  void set_has_trigger();
  void set_has_log();
  void set_has_gps_raw();

  inline bool has_payload() const;
  inline void clear_has_payload();

  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
  typedef void InternalArenaConstructable_;
  typedef void DestructorSkippable_;
  int id_;
  union PayloadUnion {
    PayloadUnion() {}
    ::sync_proto::IMU_RAW* imu_raw_;
    ::sync_proto::IMU* imu_;
    ::sync_proto::TRIGGER* trigger_;
    ::sync_proto::LOG* log_;
    ::sync_proto::GPS_RAW* gps_raw_;
  } payload_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_sync_2eproto;
};
// ===================================================================


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

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

// .sync_proto.CfgPropID prop_id = 1;
inline void ConfigItem::clear_prop_id() {
  prop_id_ = 0;
}
inline ::sync_proto::CfgPropID ConfigItem::_internal_prop_id() const {
  return static_cast< ::sync_proto::CfgPropID >(prop_id_);
}
inline ::sync_proto::CfgPropID ConfigItem::prop_id() const {
  // @@protoc_insertion_point(field_get:sync_proto.ConfigItem.prop_id)
  return _internal_prop_id();
}
inline void ConfigItem::_internal_set_prop_id(::sync_proto::CfgPropID value) {
  
  prop_id_ = value;
}
inline void ConfigItem::set_prop_id(::sync_proto::CfgPropID value) {
  _internal_set_prop_id(value);
  // @@protoc_insertion_point(field_set:sync_proto.ConfigItem.prop_id)
}

// bool bool_value = 2;
inline bool ConfigItem::_internal_has_bool_value() const {
  return value_case() == kBoolValue;
}
inline void ConfigItem::set_has_bool_value() {
  _oneof_case_[0] = kBoolValue;
}
inline void ConfigItem::clear_bool_value() {
  if (_internal_has_bool_value()) {
    value_.bool_value_ = false;
    clear_has_value();
  }
}
inline bool ConfigItem::_internal_bool_value() const {
  if (_internal_has_bool_value()) {
    return value_.bool_value_;
  }
  return false;
}
inline void ConfigItem::_internal_set_bool_value(bool value) {
  if (!_internal_has_bool_value()) {
    clear_value();
    set_has_bool_value();
  }
  value_.bool_value_ = value;
}
inline bool ConfigItem::bool_value() const {
  // @@protoc_insertion_point(field_get:sync_proto.ConfigItem.bool_value)
  return _internal_bool_value();
}
inline void ConfigItem::set_bool_value(bool value) {
  _internal_set_bool_value(value);
  // @@protoc_insertion_point(field_set:sync_proto.ConfigItem.bool_value)
}

// int32 int_value = 3;
inline bool ConfigItem::_internal_has_int_value() const {
  return value_case() == kIntValue;
}
inline void ConfigItem::set_has_int_value() {
  _oneof_case_[0] = kIntValue;
}
inline void ConfigItem::clear_int_value() {
  if (_internal_has_int_value()) {
    value_.int_value_ = 0;
    clear_has_value();
  }
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConfigItem::_internal_int_value() const {
  if (_internal_has_int_value()) {
    return value_.int_value_;
  }
  return 0;
}
inline void ConfigItem::_internal_set_int_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
  if (!_internal_has_int_value()) {
    clear_value();
    set_has_int_value();
  }
  value_.int_value_ = value;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 ConfigItem::int_value() const {
  // @@protoc_insertion_point(field_get:sync_proto.ConfigItem.int_value)
  return _internal_int_value();
}
inline void ConfigItem::set_int_value(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_int_value(value);
  // @@protoc_insertion_point(field_set:sync_proto.ConfigItem.int_value)
}

// float float_value = 4;
inline bool ConfigItem::_internal_has_float_value() const {
  return value_case() == kFloatValue;
}
inline void ConfigItem::set_has_float_value() {
  _oneof_case_[0] = kFloatValue;
}
inline void ConfigItem::clear_float_value() {
  if (_internal_has_float_value()) {
    value_.float_value_ = 0;
    clear_has_value();
  }
}
inline float ConfigItem::_internal_float_value() const {
  if (_internal_has_float_value()) {
    return value_.float_value_;
  }
  return 0;
}
inline void ConfigItem::_internal_set_float_value(float value) {
  if (!_internal_has_float_value()) {
    clear_value();
    set_has_float_value();
  }
  value_.float_value_ = value;
}
inline float ConfigItem::float_value() const {
  // @@protoc_insertion_point(field_get:sync_proto.ConfigItem.float_value)
  return _internal_float_value();
}
inline void ConfigItem::set_float_value(float value) {
  _internal_set_float_value(value);
  // @@protoc_insertion_point(field_set:sync_proto.ConfigItem.float_value)
}

// string str_value = 5;
inline bool ConfigItem::_internal_has_str_value() const {
  return value_case() == kStrValue;
}
inline void ConfigItem::set_has_str_value() {
  _oneof_case_[0] = kStrValue;
}
inline void ConfigItem::clear_str_value() {
  if (_internal_has_str_value()) {
    value_.str_value_.Destroy(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
    clear_has_value();
  }
}
inline const std::string& ConfigItem::str_value() const {
  // @@protoc_insertion_point(field_get:sync_proto.ConfigItem.str_value)
  return _internal_str_value();
}
inline void ConfigItem::set_str_value(const std::string& value) {
  _internal_set_str_value(value);
  // @@protoc_insertion_point(field_set:sync_proto.ConfigItem.str_value)
}
inline std::string* ConfigItem::mutable_str_value() {
  // @@protoc_insertion_point(field_mutable:sync_proto.ConfigItem.str_value)
  return _internal_mutable_str_value();
}
inline const std::string& ConfigItem::_internal_str_value() const {
  if (_internal_has_str_value()) {
    return value_.str_value_.Get();
  }
  return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void ConfigItem::_internal_set_str_value(const std::string& value) {
  if (!_internal_has_str_value()) {
    clear_value();
    set_has_str_value();
    value_.str_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  value_.str_value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void ConfigItem::set_str_value(std::string&& value) {
  // @@protoc_insertion_point(field_set:sync_proto.ConfigItem.str_value)
  if (!_internal_has_str_value()) {
    clear_value();
    set_has_str_value();
    value_.str_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  value_.str_value_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:sync_proto.ConfigItem.str_value)
}
inline void ConfigItem::set_str_value(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  if (!_internal_has_str_value()) {
    clear_value();
    set_has_str_value();
    value_.str_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  value_.str_value_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value), GetArena());
  // @@protoc_insertion_point(field_set_char:sync_proto.ConfigItem.str_value)
}
inline void ConfigItem::set_str_value(const char* value,
                             size_t size) {
  if (!_internal_has_str_value()) {
    clear_value();
    set_has_str_value();
    value_.str_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  value_.str_value_.Set(
      &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size),
      GetArena());
  // @@protoc_insertion_point(field_set_pointer:sync_proto.ConfigItem.str_value)
}
inline std::string* ConfigItem::_internal_mutable_str_value() {
  if (!_internal_has_str_value()) {
    clear_value();
    set_has_str_value();
    value_.str_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return value_.str_value_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* ConfigItem::release_str_value() {
  // @@protoc_insertion_point(field_release:sync_proto.ConfigItem.str_value)
  if (_internal_has_str_value()) {
    clear_has_value();
    return value_.str_value_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  } else {
    return nullptr;
  }
}
inline void ConfigItem::set_allocated_str_value(std::string* str_value) {
  if (has_value()) {
    clear_value();
  }
  if (str_value != nullptr) {
    set_has_str_value();
    value_.str_value_.UnsafeSetDefault(str_value);
  }
  // @@protoc_insertion_point(field_set_allocated:sync_proto.ConfigItem.str_value)
}
inline std::string* ConfigItem::unsafe_arena_release_str_value() {
  // @@protoc_insertion_point(field_unsafe_arena_release:sync_proto.ConfigItem.str_value)
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (_internal_has_str_value()) {
    clear_has_value();
    return value_.str_value_.UnsafeArenaRelease(
        &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
  } else {
    return nullptr;
  }
}
inline void ConfigItem::unsafe_arena_set_allocated_str_value(std::string* str_value) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (!_internal_has_str_value()) {
    value_.str_value_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  clear_value();
  if (str_value) {
    set_has_str_value();
    value_.str_value_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), str_value, GetArena());
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sync_proto.ConfigItem.str_value)
}

inline bool ConfigItem::has_value() const {
  return value_case() != VALUE_NOT_SET;
}
inline void ConfigItem::clear_has_value() {
  _oneof_case_[0] = VALUE_NOT_SET;
}
inline ConfigItem::ValueCase ConfigItem::value_case() const {
  return ConfigItem::ValueCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// Config

// repeated .sync_proto.ConfigItem item = 1;
inline int Config::_internal_item_size() const {
  return item_.size();
}
inline int Config::item_size() const {
  return _internal_item_size();
}
inline void Config::clear_item() {
  item_.Clear();
}
inline ::sync_proto::ConfigItem* Config::mutable_item(int index) {
  // @@protoc_insertion_point(field_mutable:sync_proto.Config.item)
  return item_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::sync_proto::ConfigItem >*
Config::mutable_item() {
  // @@protoc_insertion_point(field_mutable_list:sync_proto.Config.item)
  return &item_;
}
inline const ::sync_proto::ConfigItem& Config::_internal_item(int index) const {
  return item_.Get(index);
}
inline const ::sync_proto::ConfigItem& Config::item(int index) const {
  // @@protoc_insertion_point(field_get:sync_proto.Config.item)
  return _internal_item(index);
}
inline ::sync_proto::ConfigItem* Config::_internal_add_item() {
  return item_.Add();
}
inline ::sync_proto::ConfigItem* Config::add_item() {
  // @@protoc_insertion_point(field_add:sync_proto.Config.item)
  return _internal_add_item();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::sync_proto::ConfigItem >&
Config::item() const {
  // @@protoc_insertion_point(field_list:sync_proto.Config.item)
  return item_;
}

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

// IMU_RAW

// int64 time_us = 1;
inline void IMU_RAW::clear_time_us() {
  time_us_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 IMU_RAW::_internal_time_us() const {
  return time_us_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 IMU_RAW::time_us() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU_RAW.time_us)
  return _internal_time_us();
}
inline void IMU_RAW::_internal_set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  time_us_ = value;
}
inline void IMU_RAW::set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_time_us(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU_RAW.time_us)
}

// double ax = 2;
inline void IMU_RAW::clear_ax() {
  ax_ = 0;
}
inline double IMU_RAW::_internal_ax() const {
  return ax_;
}
inline double IMU_RAW::ax() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU_RAW.ax)
  return _internal_ax();
}
inline void IMU_RAW::_internal_set_ax(double value) {
  
  ax_ = value;
}
inline void IMU_RAW::set_ax(double value) {
  _internal_set_ax(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU_RAW.ax)
}

// double ay = 3;
inline void IMU_RAW::clear_ay() {
  ay_ = 0;
}
inline double IMU_RAW::_internal_ay() const {
  return ay_;
}
inline double IMU_RAW::ay() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU_RAW.ay)
  return _internal_ay();
}
inline void IMU_RAW::_internal_set_ay(double value) {
  
  ay_ = value;
}
inline void IMU_RAW::set_ay(double value) {
  _internal_set_ay(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU_RAW.ay)
}

// double az = 4;
inline void IMU_RAW::clear_az() {
  az_ = 0;
}
inline double IMU_RAW::_internal_az() const {
  return az_;
}
inline double IMU_RAW::az() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU_RAW.az)
  return _internal_az();
}
inline void IMU_RAW::_internal_set_az(double value) {
  
  az_ = value;
}
inline void IMU_RAW::set_az(double value) {
  _internal_set_az(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU_RAW.az)
}

// double gx = 5;
inline void IMU_RAW::clear_gx() {
  gx_ = 0;
}
inline double IMU_RAW::_internal_gx() const {
  return gx_;
}
inline double IMU_RAW::gx() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU_RAW.gx)
  return _internal_gx();
}
inline void IMU_RAW::_internal_set_gx(double value) {
  
  gx_ = value;
}
inline void IMU_RAW::set_gx(double value) {
  _internal_set_gx(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU_RAW.gx)
}

// double gy = 6;
inline void IMU_RAW::clear_gy() {
  gy_ = 0;
}
inline double IMU_RAW::_internal_gy() const {
  return gy_;
}
inline double IMU_RAW::gy() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU_RAW.gy)
  return _internal_gy();
}
inline void IMU_RAW::_internal_set_gy(double value) {
  
  gy_ = value;
}
inline void IMU_RAW::set_gy(double value) {
  _internal_set_gy(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU_RAW.gy)
}

// double gz = 7;
inline void IMU_RAW::clear_gz() {
  gz_ = 0;
}
inline double IMU_RAW::_internal_gz() const {
  return gz_;
}
inline double IMU_RAW::gz() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU_RAW.gz)
  return _internal_gz();
}
inline void IMU_RAW::_internal_set_gz(double value) {
  
  gz_ = value;
}
inline void IMU_RAW::set_gz(double value) {
  _internal_set_gz(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU_RAW.gz)
}

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

// IMU

// int64 time_us = 1;
inline void IMU::clear_time_us() {
  time_us_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 IMU::_internal_time_us() const {
  return time_us_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 IMU::time_us() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU.time_us)
  return _internal_time_us();
}
inline void IMU::_internal_set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  time_us_ = value;
}
inline void IMU::set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_time_us(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU.time_us)
}

// double ax = 2;
inline void IMU::clear_ax() {
  ax_ = 0;
}
inline double IMU::_internal_ax() const {
  return ax_;
}
inline double IMU::ax() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU.ax)
  return _internal_ax();
}
inline void IMU::_internal_set_ax(double value) {
  
  ax_ = value;
}
inline void IMU::set_ax(double value) {
  _internal_set_ax(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU.ax)
}

// double ay = 3;
inline void IMU::clear_ay() {
  ay_ = 0;
}
inline double IMU::_internal_ay() const {
  return ay_;
}
inline double IMU::ay() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU.ay)
  return _internal_ay();
}
inline void IMU::_internal_set_ay(double value) {
  
  ay_ = value;
}
inline void IMU::set_ay(double value) {
  _internal_set_ay(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU.ay)
}

// double az = 4;
inline void IMU::clear_az() {
  az_ = 0;
}
inline double IMU::_internal_az() const {
  return az_;
}
inline double IMU::az() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU.az)
  return _internal_az();
}
inline void IMU::_internal_set_az(double value) {
  
  az_ = value;
}
inline void IMU::set_az(double value) {
  _internal_set_az(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU.az)
}

// double gx = 5;
inline void IMU::clear_gx() {
  gx_ = 0;
}
inline double IMU::_internal_gx() const {
  return gx_;
}
inline double IMU::gx() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU.gx)
  return _internal_gx();
}
inline void IMU::_internal_set_gx(double value) {
  
  gx_ = value;
}
inline void IMU::set_gx(double value) {
  _internal_set_gx(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU.gx)
}

// double gy = 6;
inline void IMU::clear_gy() {
  gy_ = 0;
}
inline double IMU::_internal_gy() const {
  return gy_;
}
inline double IMU::gy() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU.gy)
  return _internal_gy();
}
inline void IMU::_internal_set_gy(double value) {
  
  gy_ = value;
}
inline void IMU::set_gy(double value) {
  _internal_set_gy(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU.gy)
}

// double gz = 7;
inline void IMU::clear_gz() {
  gz_ = 0;
}
inline double IMU::_internal_gz() const {
  return gz_;
}
inline double IMU::gz() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU.gz)
  return _internal_gz();
}
inline void IMU::_internal_set_gz(double value) {
  
  gz_ = value;
}
inline void IMU::set_gz(double value) {
  _internal_set_gz(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU.gz)
}

// double roll = 8;
inline void IMU::clear_roll() {
  roll_ = 0;
}
inline double IMU::_internal_roll() const {
  return roll_;
}
inline double IMU::roll() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU.roll)
  return _internal_roll();
}
inline void IMU::_internal_set_roll(double value) {
  
  roll_ = value;
}
inline void IMU::set_roll(double value) {
  _internal_set_roll(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU.roll)
}

// double pitch = 9;
inline void IMU::clear_pitch() {
  pitch_ = 0;
}
inline double IMU::_internal_pitch() const {
  return pitch_;
}
inline double IMU::pitch() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU.pitch)
  return _internal_pitch();
}
inline void IMU::_internal_set_pitch(double value) {
  
  pitch_ = value;
}
inline void IMU::set_pitch(double value) {
  _internal_set_pitch(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU.pitch)
}

// double yaw = 10;
inline void IMU::clear_yaw() {
  yaw_ = 0;
}
inline double IMU::_internal_yaw() const {
  return yaw_;
}
inline double IMU::yaw() const {
  // @@protoc_insertion_point(field_get:sync_proto.IMU.yaw)
  return _internal_yaw();
}
inline void IMU::_internal_set_yaw(double value) {
  
  yaw_ = value;
}
inline void IMU::set_yaw(double value) {
  _internal_set_yaw(value);
  // @@protoc_insertion_point(field_set:sync_proto.IMU.yaw)
}

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

// TRIGGER

// int64 trigger_time_us = 1;
inline void TRIGGER::clear_trigger_time_us() {
  trigger_time_us_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TRIGGER::_internal_trigger_time_us() const {
  return trigger_time_us_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TRIGGER::trigger_time_us() const {
  // @@protoc_insertion_point(field_get:sync_proto.TRIGGER.trigger_time_us)
  return _internal_trigger_time_us();
}
inline void TRIGGER::_internal_set_trigger_time_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  trigger_time_us_ = value;
}
inline void TRIGGER::set_trigger_time_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_trigger_time_us(value);
  // @@protoc_insertion_point(field_set:sync_proto.TRIGGER.trigger_time_us)
}

// int64 recv_trigger_time_us = 2;
inline void TRIGGER::clear_recv_trigger_time_us() {
  recv_trigger_time_us_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TRIGGER::_internal_recv_trigger_time_us() const {
  return recv_trigger_time_us_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 TRIGGER::recv_trigger_time_us() const {
  // @@protoc_insertion_point(field_get:sync_proto.TRIGGER.recv_trigger_time_us)
  return _internal_recv_trigger_time_us();
}
inline void TRIGGER::_internal_set_recv_trigger_time_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  recv_trigger_time_us_ = value;
}
inline void TRIGGER::set_recv_trigger_time_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_recv_trigger_time_us(value);
  // @@protoc_insertion_point(field_set:sync_proto.TRIGGER.recv_trigger_time_us)
}

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

// LOG

// int64 time = 1;
inline void LOG::clear_time() {
  time_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LOG::_internal_time() const {
  return time_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 LOG::time() const {
  // @@protoc_insertion_point(field_get:sync_proto.LOG.time)
  return _internal_time();
}
inline void LOG::_internal_set_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  time_ = value;
}
inline void LOG::set_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_time(value);
  // @@protoc_insertion_point(field_set:sync_proto.LOG.time)
}

// string level = 2;
inline void LOG::clear_level() {
  level_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& LOG::level() const {
  // @@protoc_insertion_point(field_get:sync_proto.LOG.level)
  return _internal_level();
}
inline void LOG::set_level(const std::string& value) {
  _internal_set_level(value);
  // @@protoc_insertion_point(field_set:sync_proto.LOG.level)
}
inline std::string* LOG::mutable_level() {
  // @@protoc_insertion_point(field_mutable:sync_proto.LOG.level)
  return _internal_mutable_level();
}
inline const std::string& LOG::_internal_level() const {
  return level_.Get();
}
inline void LOG::_internal_set_level(const std::string& value) {
  
  level_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void LOG::set_level(std::string&& value) {
  
  level_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:sync_proto.LOG.level)
}
inline void LOG::set_level(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  level_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:sync_proto.LOG.level)
}
inline void LOG::set_level(const char* value,
    size_t size) {
  
  level_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:sync_proto.LOG.level)
}
inline std::string* LOG::_internal_mutable_level() {
  
  return level_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* LOG::release_level() {
  // @@protoc_insertion_point(field_release:sync_proto.LOG.level)
  return level_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void LOG::set_allocated_level(std::string* level) {
  if (level != nullptr) {
    
  } else {
    
  }
  level_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), level,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:sync_proto.LOG.level)
}
inline std::string* LOG::unsafe_arena_release_level() {
  // @@protoc_insertion_point(field_unsafe_arena_release:sync_proto.LOG.level)
  GOOGLE_DCHECK(GetArena() != nullptr);
  
  return level_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void LOG::unsafe_arena_set_allocated_level(
    std::string* level) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (level != nullptr) {
    
  } else {
    
  }
  level_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      level, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sync_proto.LOG.level)
}

// string module = 3;
inline void LOG::clear_module() {
  module_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& LOG::module() const {
  // @@protoc_insertion_point(field_get:sync_proto.LOG.module)
  return _internal_module();
}
inline void LOG::set_module(const std::string& value) {
  _internal_set_module(value);
  // @@protoc_insertion_point(field_set:sync_proto.LOG.module)
}
inline std::string* LOG::mutable_module() {
  // @@protoc_insertion_point(field_mutable:sync_proto.LOG.module)
  return _internal_mutable_module();
}
inline const std::string& LOG::_internal_module() const {
  return module_.Get();
}
inline void LOG::_internal_set_module(const std::string& value) {
  
  module_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void LOG::set_module(std::string&& value) {
  
  module_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:sync_proto.LOG.module)
}
inline void LOG::set_module(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  module_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:sync_proto.LOG.module)
}
inline void LOG::set_module(const char* value,
    size_t size) {
  
  module_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:sync_proto.LOG.module)
}
inline std::string* LOG::_internal_mutable_module() {
  
  return module_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* LOG::release_module() {
  // @@protoc_insertion_point(field_release:sync_proto.LOG.module)
  return module_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void LOG::set_allocated_module(std::string* module) {
  if (module != nullptr) {
    
  } else {
    
  }
  module_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), module,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:sync_proto.LOG.module)
}
inline std::string* LOG::unsafe_arena_release_module() {
  // @@protoc_insertion_point(field_unsafe_arena_release:sync_proto.LOG.module)
  GOOGLE_DCHECK(GetArena() != nullptr);
  
  return module_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void LOG::unsafe_arena_set_allocated_module(
    std::string* module) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (module != nullptr) {
    
  } else {
    
  }
  module_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      module, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sync_proto.LOG.module)
}

// string message = 4;
inline void LOG::clear_message() {
  message_.ClearToEmpty(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline const std::string& LOG::message() const {
  // @@protoc_insertion_point(field_get:sync_proto.LOG.message)
  return _internal_message();
}
inline void LOG::set_message(const std::string& value) {
  _internal_set_message(value);
  // @@protoc_insertion_point(field_set:sync_proto.LOG.message)
}
inline std::string* LOG::mutable_message() {
  // @@protoc_insertion_point(field_mutable:sync_proto.LOG.message)
  return _internal_mutable_message();
}
inline const std::string& LOG::_internal_message() const {
  return message_.Get();
}
inline void LOG::_internal_set_message(const std::string& value) {
  
  message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value, GetArena());
}
inline void LOG::set_message(std::string&& value) {
  
  message_.Set(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value), GetArena());
  // @@protoc_insertion_point(field_set_rvalue:sync_proto.LOG.message)
}
inline void LOG::set_message(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value),
              GetArena());
  // @@protoc_insertion_point(field_set_char:sync_proto.LOG.message)
}
inline void LOG::set_message(const char* value,
    size_t size) {
  
  message_.Set(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size), GetArena());
  // @@protoc_insertion_point(field_set_pointer:sync_proto.LOG.message)
}
inline std::string* LOG::_internal_mutable_message() {
  
  return message_.Mutable(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline std::string* LOG::release_message() {
  // @@protoc_insertion_point(field_release:sync_proto.LOG.message)
  return message_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena());
}
inline void LOG::set_allocated_message(std::string* message) {
  if (message != nullptr) {
    
  } else {
    
  }
  message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message,
      GetArena());
  // @@protoc_insertion_point(field_set_allocated:sync_proto.LOG.message)
}
inline std::string* LOG::unsafe_arena_release_message() {
  // @@protoc_insertion_point(field_unsafe_arena_release:sync_proto.LOG.message)
  GOOGLE_DCHECK(GetArena() != nullptr);
  
  return message_.UnsafeArenaRelease(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      GetArena());
}
inline void LOG::unsafe_arena_set_allocated_message(
    std::string* message) {
  GOOGLE_DCHECK(GetArena() != nullptr);
  if (message != nullptr) {
    
  } else {
    
  }
  message_.UnsafeArenaSetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      message, GetArena());
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sync_proto.LOG.message)
}

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

// GPS_RAW

// int64 time_us = 1;
inline void GPS_RAW::clear_time_us() {
  time_us_ = PROTOBUF_LONGLONG(0);
}
inline ::PROTOBUF_NAMESPACE_ID::int64 GPS_RAW::_internal_time_us() const {
  return time_us_;
}
inline ::PROTOBUF_NAMESPACE_ID::int64 GPS_RAW::time_us() const {
  // @@protoc_insertion_point(field_get:sync_proto.GPS_RAW.time_us)
  return _internal_time_us();
}
inline void GPS_RAW::_internal_set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  
  time_us_ = value;
}
inline void GPS_RAW::set_time_us(::PROTOBUF_NAMESPACE_ID::int64 value) {
  _internal_set_time_us(value);
  // @@protoc_insertion_point(field_set:sync_proto.GPS_RAW.time_us)
}

// double latitude = 2;
inline void GPS_RAW::clear_latitude() {
  latitude_ = 0;
}
inline double GPS_RAW::_internal_latitude() const {
  return latitude_;
}
inline double GPS_RAW::latitude() const {
  // @@protoc_insertion_point(field_get:sync_proto.GPS_RAW.latitude)
  return _internal_latitude();
}
inline void GPS_RAW::_internal_set_latitude(double value) {
  
  latitude_ = value;
}
inline void GPS_RAW::set_latitude(double value) {
  _internal_set_latitude(value);
  // @@protoc_insertion_point(field_set:sync_proto.GPS_RAW.latitude)
}

// double longitude = 3;
inline void GPS_RAW::clear_longitude() {
  longitude_ = 0;
}
inline double GPS_RAW::_internal_longitude() const {
  return longitude_;
}
inline double GPS_RAW::longitude() const {
  // @@protoc_insertion_point(field_get:sync_proto.GPS_RAW.longitude)
  return _internal_longitude();
}
inline void GPS_RAW::_internal_set_longitude(double value) {
  
  longitude_ = value;
}
inline void GPS_RAW::set_longitude(double value) {
  _internal_set_longitude(value);
  // @@protoc_insertion_point(field_set:sync_proto.GPS_RAW.longitude)
}

// float altitude = 4;
inline void GPS_RAW::clear_altitude() {
  altitude_ = 0;
}
inline float GPS_RAW::_internal_altitude() const {
  return altitude_;
}
inline float GPS_RAW::altitude() const {
  // @@protoc_insertion_point(field_get:sync_proto.GPS_RAW.altitude)
  return _internal_altitude();
}
inline void GPS_RAW::_internal_set_altitude(float value) {
  
  altitude_ = value;
}
inline void GPS_RAW::set_altitude(float value) {
  _internal_set_altitude(value);
  // @@protoc_insertion_point(field_set:sync_proto.GPS_RAW.altitude)
}

// float eph = 5;
inline void GPS_RAW::clear_eph() {
  eph_ = 0;
}
inline float GPS_RAW::_internal_eph() const {
  return eph_;
}
inline float GPS_RAW::eph() const {
  // @@protoc_insertion_point(field_get:sync_proto.GPS_RAW.eph)
  return _internal_eph();
}
inline void GPS_RAW::_internal_set_eph(float value) {
  
  eph_ = value;
}
inline void GPS_RAW::set_eph(float value) {
  _internal_set_eph(value);
  // @@protoc_insertion_point(field_set:sync_proto.GPS_RAW.eph)
}

// float epv = 6;
inline void GPS_RAW::clear_epv() {
  epv_ = 0;
}
inline float GPS_RAW::_internal_epv() const {
  return epv_;
}
inline float GPS_RAW::epv() const {
  // @@protoc_insertion_point(field_get:sync_proto.GPS_RAW.epv)
  return _internal_epv();
}
inline void GPS_RAW::_internal_set_epv(float value) {
  
  epv_ = value;
}
inline void GPS_RAW::set_epv(float value) {
  _internal_set_epv(value);
  // @@protoc_insertion_point(field_set:sync_proto.GPS_RAW.epv)
}

// float vel = 7;
inline void GPS_RAW::clear_vel() {
  vel_ = 0;
}
inline float GPS_RAW::_internal_vel() const {
  return vel_;
}
inline float GPS_RAW::vel() const {
  // @@protoc_insertion_point(field_get:sync_proto.GPS_RAW.vel)
  return _internal_vel();
}
inline void GPS_RAW::_internal_set_vel(float value) {
  
  vel_ = value;
}
inline void GPS_RAW::set_vel(float value) {
  _internal_set_vel(value);
  // @@protoc_insertion_point(field_set:sync_proto.GPS_RAW.vel)
}

// float cog = 8;
inline void GPS_RAW::clear_cog() {
  cog_ = 0;
}
inline float GPS_RAW::_internal_cog() const {
  return cog_;
}
inline float GPS_RAW::cog() const {
  // @@protoc_insertion_point(field_get:sync_proto.GPS_RAW.cog)
  return _internal_cog();
}
inline void GPS_RAW::_internal_set_cog(float value) {
  
  cog_ = value;
}
inline void GPS_RAW::set_cog(float value) {
  _internal_set_cog(value);
  // @@protoc_insertion_point(field_set:sync_proto.GPS_RAW.cog)
}

// uint32 fix_type = 9;
inline void GPS_RAW::clear_fix_type() {
  fix_type_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 GPS_RAW::_internal_fix_type() const {
  return fix_type_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 GPS_RAW::fix_type() const {
  // @@protoc_insertion_point(field_get:sync_proto.GPS_RAW.fix_type)
  return _internal_fix_type();
}
inline void GPS_RAW::_internal_set_fix_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  fix_type_ = value;
}
inline void GPS_RAW::set_fix_type(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_fix_type(value);
  // @@protoc_insertion_point(field_set:sync_proto.GPS_RAW.fix_type)
}

// uint32 satellites_visible = 10;
inline void GPS_RAW::clear_satellites_visible() {
  satellites_visible_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 GPS_RAW::_internal_satellites_visible() const {
  return satellites_visible_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 GPS_RAW::satellites_visible() const {
  // @@protoc_insertion_point(field_get:sync_proto.GPS_RAW.satellites_visible)
  return _internal_satellites_visible();
}
inline void GPS_RAW::_internal_set_satellites_visible(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  satellites_visible_ = value;
}
inline void GPS_RAW::set_satellites_visible(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_satellites_visible(value);
  // @@protoc_insertion_point(field_set:sync_proto.GPS_RAW.satellites_visible)
}

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

// Envelope

// .sync_proto.MessageID id = 1;
inline void Envelope::clear_id() {
  id_ = 0;
}
inline ::sync_proto::MessageID Envelope::_internal_id() const {
  return static_cast< ::sync_proto::MessageID >(id_);
}
inline ::sync_proto::MessageID Envelope::id() const {
  // @@protoc_insertion_point(field_get:sync_proto.Envelope.id)
  return _internal_id();
}
inline void Envelope::_internal_set_id(::sync_proto::MessageID value) {
  
  id_ = value;
}
inline void Envelope::set_id(::sync_proto::MessageID value) {
  _internal_set_id(value);
  // @@protoc_insertion_point(field_set:sync_proto.Envelope.id)
}

// .sync_proto.IMU_RAW imu_raw = 2;
inline bool Envelope::_internal_has_imu_raw() const {
  return payload_case() == kImuRaw;
}
inline bool Envelope::has_imu_raw() const {
  return _internal_has_imu_raw();
}
inline void Envelope::set_has_imu_raw() {
  _oneof_case_[0] = kImuRaw;
}
inline void Envelope::clear_imu_raw() {
  if (_internal_has_imu_raw()) {
    if (GetArena() == nullptr) {
      delete payload_.imu_raw_;
    }
    clear_has_payload();
  }
}
inline ::sync_proto::IMU_RAW* Envelope::release_imu_raw() {
  // @@protoc_insertion_point(field_release:sync_proto.Envelope.imu_raw)
  if (_internal_has_imu_raw()) {
    clear_has_payload();
      ::sync_proto::IMU_RAW* temp = payload_.imu_raw_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    payload_.imu_raw_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::sync_proto::IMU_RAW& Envelope::_internal_imu_raw() const {
  return _internal_has_imu_raw()
      ? *payload_.imu_raw_
      : *reinterpret_cast< ::sync_proto::IMU_RAW*>(&::sync_proto::_IMU_RAW_default_instance_);
}
inline const ::sync_proto::IMU_RAW& Envelope::imu_raw() const {
  // @@protoc_insertion_point(field_get:sync_proto.Envelope.imu_raw)
  return _internal_imu_raw();
}
inline ::sync_proto::IMU_RAW* Envelope::unsafe_arena_release_imu_raw() {
  // @@protoc_insertion_point(field_unsafe_arena_release:sync_proto.Envelope.imu_raw)
  if (_internal_has_imu_raw()) {
    clear_has_payload();
    ::sync_proto::IMU_RAW* temp = payload_.imu_raw_;
    payload_.imu_raw_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Envelope::unsafe_arena_set_allocated_imu_raw(::sync_proto::IMU_RAW* imu_raw) {
  clear_payload();
  if (imu_raw) {
    set_has_imu_raw();
    payload_.imu_raw_ = imu_raw;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sync_proto.Envelope.imu_raw)
}
inline ::sync_proto::IMU_RAW* Envelope::_internal_mutable_imu_raw() {
  if (!_internal_has_imu_raw()) {
    clear_payload();
    set_has_imu_raw();
    payload_.imu_raw_ = CreateMaybeMessage< ::sync_proto::IMU_RAW >(GetArena());
  }
  return payload_.imu_raw_;
}
inline ::sync_proto::IMU_RAW* Envelope::mutable_imu_raw() {
  // @@protoc_insertion_point(field_mutable:sync_proto.Envelope.imu_raw)
  return _internal_mutable_imu_raw();
}

// .sync_proto.IMU imu = 3;
inline bool Envelope::_internal_has_imu() const {
  return payload_case() == kImu;
}
inline bool Envelope::has_imu() const {
  return _internal_has_imu();
}
inline void Envelope::set_has_imu() {
  _oneof_case_[0] = kImu;
}
inline void Envelope::clear_imu() {
  if (_internal_has_imu()) {
    if (GetArena() == nullptr) {
      delete payload_.imu_;
    }
    clear_has_payload();
  }
}
inline ::sync_proto::IMU* Envelope::release_imu() {
  // @@protoc_insertion_point(field_release:sync_proto.Envelope.imu)
  if (_internal_has_imu()) {
    clear_has_payload();
      ::sync_proto::IMU* temp = payload_.imu_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    payload_.imu_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::sync_proto::IMU& Envelope::_internal_imu() const {
  return _internal_has_imu()
      ? *payload_.imu_
      : *reinterpret_cast< ::sync_proto::IMU*>(&::sync_proto::_IMU_default_instance_);
}
inline const ::sync_proto::IMU& Envelope::imu() const {
  // @@protoc_insertion_point(field_get:sync_proto.Envelope.imu)
  return _internal_imu();
}
inline ::sync_proto::IMU* Envelope::unsafe_arena_release_imu() {
  // @@protoc_insertion_point(field_unsafe_arena_release:sync_proto.Envelope.imu)
  if (_internal_has_imu()) {
    clear_has_payload();
    ::sync_proto::IMU* temp = payload_.imu_;
    payload_.imu_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Envelope::unsafe_arena_set_allocated_imu(::sync_proto::IMU* imu) {
  clear_payload();
  if (imu) {
    set_has_imu();
    payload_.imu_ = imu;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sync_proto.Envelope.imu)
}
inline ::sync_proto::IMU* Envelope::_internal_mutable_imu() {
  if (!_internal_has_imu()) {
    clear_payload();
    set_has_imu();
    payload_.imu_ = CreateMaybeMessage< ::sync_proto::IMU >(GetArena());
  }
  return payload_.imu_;
}
inline ::sync_proto::IMU* Envelope::mutable_imu() {
  // @@protoc_insertion_point(field_mutable:sync_proto.Envelope.imu)
  return _internal_mutable_imu();
}

// .sync_proto.TRIGGER trigger = 4;
inline bool Envelope::_internal_has_trigger() const {
  return payload_case() == kTrigger;
}
inline bool Envelope::has_trigger() const {
  return _internal_has_trigger();
}
inline void Envelope::set_has_trigger() {
  _oneof_case_[0] = kTrigger;
}
inline void Envelope::clear_trigger() {
  if (_internal_has_trigger()) {
    if (GetArena() == nullptr) {
      delete payload_.trigger_;
    }
    clear_has_payload();
  }
}
inline ::sync_proto::TRIGGER* Envelope::release_trigger() {
  // @@protoc_insertion_point(field_release:sync_proto.Envelope.trigger)
  if (_internal_has_trigger()) {
    clear_has_payload();
      ::sync_proto::TRIGGER* temp = payload_.trigger_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    payload_.trigger_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::sync_proto::TRIGGER& Envelope::_internal_trigger() const {
  return _internal_has_trigger()
      ? *payload_.trigger_
      : *reinterpret_cast< ::sync_proto::TRIGGER*>(&::sync_proto::_TRIGGER_default_instance_);
}
inline const ::sync_proto::TRIGGER& Envelope::trigger() const {
  // @@protoc_insertion_point(field_get:sync_proto.Envelope.trigger)
  return _internal_trigger();
}
inline ::sync_proto::TRIGGER* Envelope::unsafe_arena_release_trigger() {
  // @@protoc_insertion_point(field_unsafe_arena_release:sync_proto.Envelope.trigger)
  if (_internal_has_trigger()) {
    clear_has_payload();
    ::sync_proto::TRIGGER* temp = payload_.trigger_;
    payload_.trigger_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Envelope::unsafe_arena_set_allocated_trigger(::sync_proto::TRIGGER* trigger) {
  clear_payload();
  if (trigger) {
    set_has_trigger();
    payload_.trigger_ = trigger;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sync_proto.Envelope.trigger)
}
inline ::sync_proto::TRIGGER* Envelope::_internal_mutable_trigger() {
  if (!_internal_has_trigger()) {
    clear_payload();
    set_has_trigger();
    payload_.trigger_ = CreateMaybeMessage< ::sync_proto::TRIGGER >(GetArena());
  }
  return payload_.trigger_;
}
inline ::sync_proto::TRIGGER* Envelope::mutable_trigger() {
  // @@protoc_insertion_point(field_mutable:sync_proto.Envelope.trigger)
  return _internal_mutable_trigger();
}

// .sync_proto.LOG log = 5;
inline bool Envelope::_internal_has_log() const {
  return payload_case() == kLog;
}
inline bool Envelope::has_log() const {
  return _internal_has_log();
}
inline void Envelope::set_has_log() {
  _oneof_case_[0] = kLog;
}
inline void Envelope::clear_log() {
  if (_internal_has_log()) {
    if (GetArena() == nullptr) {
      delete payload_.log_;
    }
    clear_has_payload();
  }
}
inline ::sync_proto::LOG* Envelope::release_log() {
  // @@protoc_insertion_point(field_release:sync_proto.Envelope.log)
  if (_internal_has_log()) {
    clear_has_payload();
      ::sync_proto::LOG* temp = payload_.log_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    payload_.log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::sync_proto::LOG& Envelope::_internal_log() const {
  return _internal_has_log()
      ? *payload_.log_
      : *reinterpret_cast< ::sync_proto::LOG*>(&::sync_proto::_LOG_default_instance_);
}
inline const ::sync_proto::LOG& Envelope::log() const {
  // @@protoc_insertion_point(field_get:sync_proto.Envelope.log)
  return _internal_log();
}
inline ::sync_proto::LOG* Envelope::unsafe_arena_release_log() {
  // @@protoc_insertion_point(field_unsafe_arena_release:sync_proto.Envelope.log)
  if (_internal_has_log()) {
    clear_has_payload();
    ::sync_proto::LOG* temp = payload_.log_;
    payload_.log_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Envelope::unsafe_arena_set_allocated_log(::sync_proto::LOG* log) {
  clear_payload();
  if (log) {
    set_has_log();
    payload_.log_ = log;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sync_proto.Envelope.log)
}
inline ::sync_proto::LOG* Envelope::_internal_mutable_log() {
  if (!_internal_has_log()) {
    clear_payload();
    set_has_log();
    payload_.log_ = CreateMaybeMessage< ::sync_proto::LOG >(GetArena());
  }
  return payload_.log_;
}
inline ::sync_proto::LOG* Envelope::mutable_log() {
  // @@protoc_insertion_point(field_mutable:sync_proto.Envelope.log)
  return _internal_mutable_log();
}

// .sync_proto.GPS_RAW gps_raw = 6;
inline bool Envelope::_internal_has_gps_raw() const {
  return payload_case() == kGpsRaw;
}
inline bool Envelope::has_gps_raw() const {
  return _internal_has_gps_raw();
}
inline void Envelope::set_has_gps_raw() {
  _oneof_case_[0] = kGpsRaw;
}
inline void Envelope::clear_gps_raw() {
  if (_internal_has_gps_raw()) {
    if (GetArena() == nullptr) {
      delete payload_.gps_raw_;
    }
    clear_has_payload();
  }
}
inline ::sync_proto::GPS_RAW* Envelope::release_gps_raw() {
  // @@protoc_insertion_point(field_release:sync_proto.Envelope.gps_raw)
  if (_internal_has_gps_raw()) {
    clear_has_payload();
      ::sync_proto::GPS_RAW* temp = payload_.gps_raw_;
    if (GetArena() != nullptr) {
      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
    }
    payload_.gps_raw_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline const ::sync_proto::GPS_RAW& Envelope::_internal_gps_raw() const {
  return _internal_has_gps_raw()
      ? *payload_.gps_raw_
      : *reinterpret_cast< ::sync_proto::GPS_RAW*>(&::sync_proto::_GPS_RAW_default_instance_);
}
inline const ::sync_proto::GPS_RAW& Envelope::gps_raw() const {
  // @@protoc_insertion_point(field_get:sync_proto.Envelope.gps_raw)
  return _internal_gps_raw();
}
inline ::sync_proto::GPS_RAW* Envelope::unsafe_arena_release_gps_raw() {
  // @@protoc_insertion_point(field_unsafe_arena_release:sync_proto.Envelope.gps_raw)
  if (_internal_has_gps_raw()) {
    clear_has_payload();
    ::sync_proto::GPS_RAW* temp = payload_.gps_raw_;
    payload_.gps_raw_ = nullptr;
    return temp;
  } else {
    return nullptr;
  }
}
inline void Envelope::unsafe_arena_set_allocated_gps_raw(::sync_proto::GPS_RAW* gps_raw) {
  clear_payload();
  if (gps_raw) {
    set_has_gps_raw();
    payload_.gps_raw_ = gps_raw;
  }
  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:sync_proto.Envelope.gps_raw)
}
inline ::sync_proto::GPS_RAW* Envelope::_internal_mutable_gps_raw() {
  if (!_internal_has_gps_raw()) {
    clear_payload();
    set_has_gps_raw();
    payload_.gps_raw_ = CreateMaybeMessage< ::sync_proto::GPS_RAW >(GetArena());
  }
  return payload_.gps_raw_;
}
inline ::sync_proto::GPS_RAW* Envelope::mutable_gps_raw() {
  // @@protoc_insertion_point(field_mutable:sync_proto.Envelope.gps_raw)
  return _internal_mutable_gps_raw();
}

inline bool Envelope::has_payload() const {
  return payload_case() != PAYLOAD_NOT_SET;
}
inline void Envelope::clear_has_payload() {
  _oneof_case_[0] = PAYLOAD_NOT_SET;
}
inline Envelope::PayloadCase Envelope::payload_case() const {
  return Envelope::PayloadCase(_oneof_case_[0]);
}
#ifdef __GNUC__
  #pragma GCC diagnostic pop
#endif  // __GNUC__
// -------------------------------------------------------------------

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace sync_proto

PROTOBUF_NAMESPACE_OPEN

template <> struct is_proto_enum< ::sync_proto::MessageID> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::sync_proto::MessageID>() {
  return ::sync_proto::MessageID_descriptor();
}
template <> struct is_proto_enum< ::sync_proto::CfgPropID> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::sync_proto::CfgPropID>() {
  return ::sync_proto::CfgPropID_descriptor();
}
template <> struct is_proto_enum< ::sync_proto::LogLevel> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::sync_proto::LogLevel>() {
  return ::sync_proto::LogLevel_descriptor();
}
template <> struct is_proto_enum< ::sync_proto::GPSSatStatus> : ::std::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::sync_proto::GPSSatStatus>() {
  return ::sync_proto::GPSSatStatus_descriptor();
}

PROTOBUF_NAMESPACE_CLOSE

// @@protoc_insertion_point(global_scope)

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