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

#ifndef GOOGLE_PROTOBUF_INCLUDED_ComInterfaceCommandsPb_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_ComInterfaceCommandsPb_2eproto

#include <limits>
#include <string>

#include <google/protobuf/port_def.inc>
#if PROTOBUF_VERSION < 3010000
#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 3010001 < 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.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/unknown_field_set.h>
#include "ComInterfaceDataModelsPb.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_ComInterfaceCommandsPb_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_ComInterfaceCommandsPb_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[16]
    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_ComInterfaceCommandsPb_2eproto;
namespace OpenTestSystem {
namespace OtxDiagManager {
namespace Common {
class ActivateEthernetPb;
class ActivateEthernetPbDefaultTypeInternal;
extern ActivateEthernetPbDefaultTypeInternal _ActivateEthernetPb_default_instance_;
class CloseComInterfacePb;
class CloseComInterfacePbDefaultTypeInternal;
extern CloseComInterfacePbDefaultTypeInternal _CloseComInterfacePb_default_instance_;
class ConnectComInterfacePb;
class ConnectComInterfacePbDefaultTypeInternal;
extern ConnectComInterfacePbDefaultTypeInternal _ConnectComInterfacePb_default_instance_;
class CreateComChannelFromComInterfacePb;
class CreateComChannelFromComInterfacePbDefaultTypeInternal;
extern CreateComChannelFromComInterfacePbDefaultTypeInternal _CreateComChannelFromComInterfacePb_default_instance_;
class DeactivateEthernetPb;
class DeactivateEthernetPbDefaultTypeInternal;
extern DeactivateEthernetPbDefaultTypeInternal _DeactivateEthernetPb_default_instance_;
class GetBatteryVoltageFromComInterfacePb;
class GetBatteryVoltageFromComInterfacePbDefaultTypeInternal;
extern GetBatteryVoltageFromComInterfacePbDefaultTypeInternal _GetBatteryVoltageFromComInterfacePb_default_instance_;
class GetComChannelFromComInterfacePb;
class GetComChannelFromComInterfacePbDefaultTypeInternal;
extern GetComChannelFromComInterfacePbDefaultTypeInternal _GetComChannelFromComInterfacePb_default_instance_;
class GetComInterfaceNameListFromEthernetPb;
class GetComInterfaceNameListFromEthernetPbDefaultTypeInternal;
extern GetComInterfaceNameListFromEthernetPbDefaultTypeInternal _GetComInterfaceNameListFromEthernetPb_default_instance_;
class GetComInterfaceNameListPb;
class GetComInterfaceNameListPbDefaultTypeInternal;
extern GetComInterfaceNameListPbDefaultTypeInternal _GetComInterfaceNameListPb_default_instance_;
class GetComInterfacePb;
class GetComInterfacePbDefaultTypeInternal;
extern GetComInterfacePbDefaultTypeInternal _GetComInterfacePb_default_instance_;
class GetComInterfacePropertiesPb;
class GetComInterfacePropertiesPbDefaultTypeInternal;
extern GetComInterfacePropertiesPbDefaultTypeInternal _GetComInterfacePropertiesPb_default_instance_;
class GetComInterfaceResourceNameListPb;
class GetComInterfaceResourceNameListPbDefaultTypeInternal;
extern GetComInterfaceResourceNameListPbDefaultTypeInternal _GetComInterfaceResourceNameListPb_default_instance_;
class GetDefaultComInterfaceNamePb;
class GetDefaultComInterfaceNamePbDefaultTypeInternal;
extern GetDefaultComInterfaceNamePbDefaultTypeInternal _GetDefaultComInterfaceNamePb_default_instance_;
class GetIgnitionStateFromComInterfacePb;
class GetIgnitionStateFromComInterfacePbDefaultTypeInternal;
extern GetIgnitionStateFromComInterfacePbDefaultTypeInternal _GetIgnitionStateFromComInterfacePb_default_instance_;
class IsEthernetActivatedPb;
class IsEthernetActivatedPbDefaultTypeInternal;
extern IsEthernetActivatedPbDefaultTypeInternal _IsEthernetActivatedPb_default_instance_;
class IsInterfaceConnectedPb;
class IsInterfaceConnectedPbDefaultTypeInternal;
extern IsInterfaceConnectedPbDefaultTypeInternal _IsInterfaceConnectedPb_default_instance_;
}  // namespace Common
}  // namespace OtxDiagManager
}  // namespace OpenTestSystem
PROTOBUF_NAMESPACE_OPEN
template<> ::OpenTestSystem::OtxDiagManager::Common::ActivateEthernetPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::ActivateEthernetPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::CloseComInterfacePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::CloseComInterfacePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::ConnectComInterfacePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::ConnectComInterfacePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::CreateComChannelFromComInterfacePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::CreateComChannelFromComInterfacePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::DeactivateEthernetPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DeactivateEthernetPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetBatteryVoltageFromComInterfacePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetBatteryVoltageFromComInterfacePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetComChannelFromComInterfacePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetComChannelFromComInterfacePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetComInterfaceNameListFromEthernetPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetComInterfaceNameListFromEthernetPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetComInterfaceNameListPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetComInterfaceNameListPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetComInterfacePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetComInterfacePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetComInterfacePropertiesPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetComInterfacePropertiesPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetComInterfaceResourceNameListPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetComInterfaceResourceNameListPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetDefaultComInterfaceNamePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetDefaultComInterfaceNamePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetIgnitionStateFromComInterfacePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetIgnitionStateFromComInterfacePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::IsEthernetActivatedPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::IsEthernetActivatedPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::IsInterfaceConnectedPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::IsInterfaceConnectedPb>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace OpenTestSystem {
namespace OtxDiagManager {
namespace Common {

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

class ActivateEthernetPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.ActivateEthernetPb) */ {
 public:
  ActivateEthernetPb();
  virtual ~ActivateEthernetPb();

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

  inline ActivateEthernetPb& operator=(const ActivateEthernetPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline ActivateEthernetPb& operator=(ActivateEthernetPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 ActivateEthernetPb& default_instance();

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

  friend void swap(ActivateEthernetPb& a, ActivateEthernetPb& b) {
    a.Swap(&b);
  }
  inline void Swap(ActivateEthernetPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  ActivateEthernetPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ActivateEthernetPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ActivateEthernetPb& from);
  void MergeFrom(const ActivateEthernetPb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(ActivateEthernetPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.ActivateEthernetPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kComInterfaceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.ActivateEthernetPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class CloseComInterfacePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.CloseComInterfacePb) */ {
 public:
  CloseComInterfacePb();
  virtual ~CloseComInterfacePb();

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

  inline CloseComInterfacePb& operator=(const CloseComInterfacePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline CloseComInterfacePb& operator=(CloseComInterfacePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 CloseComInterfacePb& default_instance();

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

  friend void swap(CloseComInterfacePb& a, CloseComInterfacePb& b) {
    a.Swap(&b);
  }
  inline void Swap(CloseComInterfacePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  CloseComInterfacePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CloseComInterfacePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CloseComInterfacePb& from);
  void MergeFrom(const CloseComInterfacePb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(CloseComInterfacePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.CloseComInterfacePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kComInterfaceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.CloseComInterfacePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class ConnectComInterfacePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.ConnectComInterfacePb) */ {
 public:
  ConnectComInterfacePb();
  virtual ~ConnectComInterfacePb();

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

  inline ConnectComInterfacePb& operator=(const ConnectComInterfacePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline ConnectComInterfacePb& operator=(ConnectComInterfacePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 ConnectComInterfacePb& default_instance();

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

  friend void swap(ConnectComInterfacePb& a, ConnectComInterfacePb& b) {
    a.Swap(&b);
  }
  inline void Swap(ConnectComInterfacePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  ConnectComInterfacePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ConnectComInterfacePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ConnectComInterfacePb& from);
  void MergeFrom(const ConnectComInterfacePb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(ConnectComInterfacePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.ConnectComInterfacePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kComInterfaceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.ConnectComInterfacePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class DeactivateEthernetPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.DeactivateEthernetPb) */ {
 public:
  DeactivateEthernetPb();
  virtual ~DeactivateEthernetPb();

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

  inline DeactivateEthernetPb& operator=(const DeactivateEthernetPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline DeactivateEthernetPb& operator=(DeactivateEthernetPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 DeactivateEthernetPb& default_instance();

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

  friend void swap(DeactivateEthernetPb& a, DeactivateEthernetPb& b) {
    a.Swap(&b);
  }
  inline void Swap(DeactivateEthernetPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  DeactivateEthernetPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<DeactivateEthernetPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const DeactivateEthernetPb& from);
  void MergeFrom(const DeactivateEthernetPb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(DeactivateEthernetPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.DeactivateEthernetPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kComInterfaceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.DeactivateEthernetPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class CreateComChannelFromComInterfacePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb) */ {
 public:
  CreateComChannelFromComInterfacePb();
  virtual ~CreateComChannelFromComInterfacePb();

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

  inline CreateComChannelFromComInterfacePb& operator=(const CreateComChannelFromComInterfacePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline CreateComChannelFromComInterfacePb& operator=(CreateComChannelFromComInterfacePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 CreateComChannelFromComInterfacePb& default_instance();

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

  friend void swap(CreateComChannelFromComInterfacePb& a, CreateComChannelFromComInterfacePb& b) {
    a.Swap(&b);
  }
  inline void Swap(CreateComChannelFromComInterfacePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  CreateComChannelFromComInterfacePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateComChannelFromComInterfacePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateComChannelFromComInterfacePb& from);
  void MergeFrom(const CreateComChannelFromComInterfacePb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(CreateComChannelFromComInterfacePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kIdentifierFieldNumber = 2,
    kEcuVariantNameFieldNumber = 3,
    kResourceFieldNumber = 4,
    kComInterfaceFieldNumber = 1,
  };
  // string Identifier = 2;
  void clear_identifier();
  const std::string& identifier() const;
  void set_identifier(const std::string& value);
  void set_identifier(std::string&& value);
  void set_identifier(const char* value);
  void set_identifier(const char* value, size_t size);
  std::string* mutable_identifier();
  std::string* release_identifier();
  void set_allocated_identifier(std::string* identifier);
  private:
  const std::string& _internal_identifier() const;
  void _internal_set_identifier(const std::string& value);
  std::string* _internal_mutable_identifier();
  public:

  // string EcuVariantName = 3;
  void clear_ecuvariantname();
  const std::string& ecuvariantname() const;
  void set_ecuvariantname(const std::string& value);
  void set_ecuvariantname(std::string&& value);
  void set_ecuvariantname(const char* value);
  void set_ecuvariantname(const char* value, size_t size);
  std::string* mutable_ecuvariantname();
  std::string* release_ecuvariantname();
  void set_allocated_ecuvariantname(std::string* ecuvariantname);
  private:
  const std::string& _internal_ecuvariantname() const;
  void _internal_set_ecuvariantname(const std::string& value);
  std::string* _internal_mutable_ecuvariantname();
  public:

  // string Resource = 4;
  void clear_resource();
  const std::string& resource() const;
  void set_resource(const std::string& value);
  void set_resource(std::string&& value);
  void set_resource(const char* value);
  void set_resource(const char* value, size_t size);
  std::string* mutable_resource();
  std::string* release_resource();
  void set_allocated_resource(std::string* resource);
  private:
  const std::string& _internal_resource() const;
  void _internal_set_resource(const std::string& value);
  std::string* _internal_mutable_resource();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identifier_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ecuvariantname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr resource_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetBatteryVoltageFromComInterfacePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetBatteryVoltageFromComInterfacePb) */ {
 public:
  GetBatteryVoltageFromComInterfacePb();
  virtual ~GetBatteryVoltageFromComInterfacePb();

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

  inline GetBatteryVoltageFromComInterfacePb& operator=(const GetBatteryVoltageFromComInterfacePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetBatteryVoltageFromComInterfacePb& operator=(GetBatteryVoltageFromComInterfacePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 GetBatteryVoltageFromComInterfacePb& default_instance();

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

  friend void swap(GetBatteryVoltageFromComInterfacePb& a, GetBatteryVoltageFromComInterfacePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetBatteryVoltageFromComInterfacePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  GetBatteryVoltageFromComInterfacePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetBatteryVoltageFromComInterfacePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetBatteryVoltageFromComInterfacePb& from);
  void MergeFrom(const GetBatteryVoltageFromComInterfacePb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(GetBatteryVoltageFromComInterfacePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetBatteryVoltageFromComInterfacePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kComInterfaceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetBatteryVoltageFromComInterfacePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetComChannelFromComInterfacePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb) */ {
 public:
  GetComChannelFromComInterfacePb();
  virtual ~GetComChannelFromComInterfacePb();

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

  inline GetComChannelFromComInterfacePb& operator=(const GetComChannelFromComInterfacePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetComChannelFromComInterfacePb& operator=(GetComChannelFromComInterfacePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 GetComChannelFromComInterfacePb& default_instance();

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

  friend void swap(GetComChannelFromComInterfacePb& a, GetComChannelFromComInterfacePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetComChannelFromComInterfacePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  GetComChannelFromComInterfacePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetComChannelFromComInterfacePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetComChannelFromComInterfacePb& from);
  void MergeFrom(const GetComChannelFromComInterfacePb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(GetComChannelFromComInterfacePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kIdentifierFieldNumber = 2,
    kEcuVariantNameFieldNumber = 3,
    kResourceFieldNumber = 5,
    kComInterfaceFieldNumber = 1,
    kPerformVariantSelectionFieldNumber = 4,
  };
  // string Identifier = 2;
  void clear_identifier();
  const std::string& identifier() const;
  void set_identifier(const std::string& value);
  void set_identifier(std::string&& value);
  void set_identifier(const char* value);
  void set_identifier(const char* value, size_t size);
  std::string* mutable_identifier();
  std::string* release_identifier();
  void set_allocated_identifier(std::string* identifier);
  private:
  const std::string& _internal_identifier() const;
  void _internal_set_identifier(const std::string& value);
  std::string* _internal_mutable_identifier();
  public:

  // string EcuVariantName = 3;
  void clear_ecuvariantname();
  const std::string& ecuvariantname() const;
  void set_ecuvariantname(const std::string& value);
  void set_ecuvariantname(std::string&& value);
  void set_ecuvariantname(const char* value);
  void set_ecuvariantname(const char* value, size_t size);
  std::string* mutable_ecuvariantname();
  std::string* release_ecuvariantname();
  void set_allocated_ecuvariantname(std::string* ecuvariantname);
  private:
  const std::string& _internal_ecuvariantname() const;
  void _internal_set_ecuvariantname(const std::string& value);
  std::string* _internal_mutable_ecuvariantname();
  public:

  // string Resource = 5;
  void clear_resource();
  const std::string& resource() const;
  void set_resource(const std::string& value);
  void set_resource(std::string&& value);
  void set_resource(const char* value);
  void set_resource(const char* value, size_t size);
  std::string* mutable_resource();
  std::string* release_resource();
  void set_allocated_resource(std::string* resource);
  private:
  const std::string& _internal_resource() const;
  void _internal_set_resource(const std::string& value);
  std::string* _internal_mutable_resource();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // bool PerformVariantSelection = 4;
  void clear_performvariantselection();
  bool performvariantselection() const;
  void set_performvariantselection(bool value);
  private:
  bool _internal_performvariantselection() const;
  void _internal_set_performvariantselection(bool value);
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identifier_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ecuvariantname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr resource_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  bool performvariantselection_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetComInterfacePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePb) */ {
 public:
  GetComInterfacePb();
  virtual ~GetComInterfacePb();

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

  inline GetComInterfacePb& operator=(const GetComInterfacePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetComInterfacePb& operator=(GetComInterfacePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 GetComInterfacePb& default_instance();

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

  friend void swap(GetComInterfacePb& a, GetComInterfacePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetComInterfacePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  GetComInterfacePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetComInterfacePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetComInterfacePb& from);
  void MergeFrom(const GetComInterfacePb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(GetComInterfacePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetComInterfacePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kComInterfaceNameFieldNumber = 1,
  };
  // string ComInterfaceName = 1;
  void clear_cominterfacename();
  const std::string& cominterfacename() const;
  void set_cominterfacename(const std::string& value);
  void set_cominterfacename(std::string&& value);
  void set_cominterfacename(const char* value);
  void set_cominterfacename(const char* value, size_t size);
  std::string* mutable_cominterfacename();
  std::string* release_cominterfacename();
  void set_allocated_cominterfacename(std::string* cominterfacename);
  private:
  const std::string& _internal_cominterfacename() const;
  void _internal_set_cominterfacename(const std::string& value);
  std::string* _internal_mutable_cominterfacename();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr cominterfacename_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetComInterfaceNameListPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListPb) */ {
 public:
  GetComInterfaceNameListPb();
  virtual ~GetComInterfaceNameListPb();

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

  inline GetComInterfaceNameListPb& operator=(const GetComInterfaceNameListPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetComInterfaceNameListPb& operator=(GetComInterfaceNameListPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 GetComInterfaceNameListPb& default_instance();

  enum KindCase {
    kConnectionStates = 1,
    KIND_NOT_SET = 0,
  };

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

  friend void swap(GetComInterfaceNameListPb& a, GetComInterfaceNameListPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetComInterfaceNameListPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  GetComInterfaceNameListPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetComInterfaceNameListPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetComInterfaceNameListPb& from);
  void MergeFrom(const GetComInterfaceNameListPb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(GetComInterfaceNameListPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kConnectionStatesFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DConnectionStatesPb ConnectionStates = 1;
  private:
  bool _internal_has_connectionstates() const;
  public:
  void clear_connectionstates();
  ::OpenTestSystem::OtxDiagManager::Common::DConnectionStatesPb connectionstates() const;
  void set_connectionstates(::OpenTestSystem::OtxDiagManager::Common::DConnectionStatesPb value);
  private:
  ::OpenTestSystem::OtxDiagManager::Common::DConnectionStatesPb _internal_connectionstates() const;
  void _internal_set_connectionstates(::OpenTestSystem::OtxDiagManager::Common::DConnectionStatesPb value);
  public:

  void clear_kind();
  KindCase kind_case() const;
  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListPb)
 private:
  class _Internal;
  void set_has_connectionstates();

  inline bool has_kind() const;
  inline void clear_has_kind();

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  union KindUnion {
    KindUnion() {}
    int connectionstates_;
  } kind_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetComInterfaceNameListFromEthernetPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb) */ {
 public:
  GetComInterfaceNameListFromEthernetPb();
  virtual ~GetComInterfaceNameListFromEthernetPb();

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

  inline GetComInterfaceNameListFromEthernetPb& operator=(const GetComInterfaceNameListFromEthernetPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetComInterfaceNameListFromEthernetPb& operator=(GetComInterfaceNameListFromEthernetPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 GetComInterfaceNameListFromEthernetPb& default_instance();

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

  friend void swap(GetComInterfaceNameListFromEthernetPb& a, GetComInterfaceNameListFromEthernetPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetComInterfaceNameListFromEthernetPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  GetComInterfaceNameListFromEthernetPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetComInterfaceNameListFromEthernetPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetComInterfaceNameListFromEthernetPb& from);
  void MergeFrom(const GetComInterfaceNameListFromEthernetPb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(GetComInterfaceNameListFromEthernetPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kOptionStringFieldNumber = 2,
    kComInterfaceFieldNumber = 1,
  };
  // string OptionString = 2;
  void clear_optionstring();
  const std::string& optionstring() const;
  void set_optionstring(const std::string& value);
  void set_optionstring(std::string&& value);
  void set_optionstring(const char* value);
  void set_optionstring(const char* value, size_t size);
  std::string* mutable_optionstring();
  std::string* release_optionstring();
  void set_allocated_optionstring(std::string* optionstring);
  private:
  const std::string& _internal_optionstring() const;
  void _internal_set_optionstring(const std::string& value);
  std::string* _internal_mutable_optionstring();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr optionstring_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetComInterfacePropertiesPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePropertiesPb) */ {
 public:
  GetComInterfacePropertiesPb();
  virtual ~GetComInterfacePropertiesPb();

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

  inline GetComInterfacePropertiesPb& operator=(const GetComInterfacePropertiesPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetComInterfacePropertiesPb& operator=(GetComInterfacePropertiesPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 GetComInterfacePropertiesPb& default_instance();

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

  friend void swap(GetComInterfacePropertiesPb& a, GetComInterfacePropertiesPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetComInterfacePropertiesPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  GetComInterfacePropertiesPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetComInterfacePropertiesPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetComInterfacePropertiesPb& from);
  void MergeFrom(const GetComInterfacePropertiesPb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(GetComInterfacePropertiesPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetComInterfacePropertiesPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kComInterfaceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePropertiesPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetComInterfaceResourceNameListPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceResourceNameListPb) */ {
 public:
  GetComInterfaceResourceNameListPb();
  virtual ~GetComInterfaceResourceNameListPb();

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

  inline GetComInterfaceResourceNameListPb& operator=(const GetComInterfaceResourceNameListPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetComInterfaceResourceNameListPb& operator=(GetComInterfaceResourceNameListPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 GetComInterfaceResourceNameListPb& default_instance();

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

  friend void swap(GetComInterfaceResourceNameListPb& a, GetComInterfaceResourceNameListPb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetComInterfaceResourceNameListPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  GetComInterfaceResourceNameListPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetComInterfaceResourceNameListPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetComInterfaceResourceNameListPb& from);
  void MergeFrom(const GetComInterfaceResourceNameListPb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(GetComInterfaceResourceNameListPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetComInterfaceResourceNameListPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kComInterfaceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceResourceNameListPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetDefaultComInterfaceNamePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetDefaultComInterfaceNamePb) */ {
 public:
  GetDefaultComInterfaceNamePb();
  virtual ~GetDefaultComInterfaceNamePb();

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

  inline GetDefaultComInterfaceNamePb& operator=(const GetDefaultComInterfaceNamePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetDefaultComInterfaceNamePb& operator=(GetDefaultComInterfaceNamePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 GetDefaultComInterfaceNamePb& default_instance();

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

  friend void swap(GetDefaultComInterfaceNamePb& a, GetDefaultComInterfaceNamePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetDefaultComInterfaceNamePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  GetDefaultComInterfaceNamePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetDefaultComInterfaceNamePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetDefaultComInterfaceNamePb& from);
  void MergeFrom(const GetDefaultComInterfaceNamePb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(GetDefaultComInterfaceNamePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetDefaultComInterfaceNamePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetDefaultComInterfaceNamePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class GetIgnitionStateFromComInterfacePb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStateFromComInterfacePb) */ {
 public:
  GetIgnitionStateFromComInterfacePb();
  virtual ~GetIgnitionStateFromComInterfacePb();

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

  inline GetIgnitionStateFromComInterfacePb& operator=(const GetIgnitionStateFromComInterfacePb& from) {
    CopyFrom(from);
    return *this;
  }
  inline GetIgnitionStateFromComInterfacePb& operator=(GetIgnitionStateFromComInterfacePb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 GetIgnitionStateFromComInterfacePb& default_instance();

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

  friend void swap(GetIgnitionStateFromComInterfacePb& a, GetIgnitionStateFromComInterfacePb& b) {
    a.Swap(&b);
  }
  inline void Swap(GetIgnitionStateFromComInterfacePb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  GetIgnitionStateFromComInterfacePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetIgnitionStateFromComInterfacePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetIgnitionStateFromComInterfacePb& from);
  void MergeFrom(const GetIgnitionStateFromComInterfacePb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(GetIgnitionStateFromComInterfacePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetIgnitionStateFromComInterfacePb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kComInterfaceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStateFromComInterfacePb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class IsEthernetActivatedPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.IsEthernetActivatedPb) */ {
 public:
  IsEthernetActivatedPb();
  virtual ~IsEthernetActivatedPb();

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

  inline IsEthernetActivatedPb& operator=(const IsEthernetActivatedPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline IsEthernetActivatedPb& operator=(IsEthernetActivatedPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 IsEthernetActivatedPb& default_instance();

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

  friend void swap(IsEthernetActivatedPb& a, IsEthernetActivatedPb& b) {
    a.Swap(&b);
  }
  inline void Swap(IsEthernetActivatedPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  IsEthernetActivatedPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IsEthernetActivatedPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IsEthernetActivatedPb& from);
  void MergeFrom(const IsEthernetActivatedPb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(IsEthernetActivatedPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.IsEthernetActivatedPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kComInterfaceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.IsEthernetActivatedPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// -------------------------------------------------------------------

class IsInterfaceConnectedPb :
    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:OpenTestSystem.OtxDiagManager.Common.IsInterfaceConnectedPb) */ {
 public:
  IsInterfaceConnectedPb();
  virtual ~IsInterfaceConnectedPb();

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

  inline IsInterfaceConnectedPb& operator=(const IsInterfaceConnectedPb& from) {
    CopyFrom(from);
    return *this;
  }
  inline IsInterfaceConnectedPb& operator=(IsInterfaceConnectedPb&& from) noexcept {
    if (GetArenaNoVirtual() == from.GetArenaNoVirtual()) {
      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 IsInterfaceConnectedPb& default_instance();

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

  friend void swap(IsInterfaceConnectedPb& a, IsInterfaceConnectedPb& b) {
    a.Swap(&b);
  }
  inline void Swap(IsInterfaceConnectedPb* other) {
    if (other == this) return;
    InternalSwap(other);
  }

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

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

  IsInterfaceConnectedPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IsInterfaceConnectedPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IsInterfaceConnectedPb& from);
  void MergeFrom(const IsInterfaceConnectedPb& 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* InternalSerializeWithCachedSizesToArray(
      ::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(IsInterfaceConnectedPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.IsInterfaceConnectedPb";
  }
  private:
  inline ::PROTOBUF_NAMESPACE_ID::Arena* GetArenaNoVirtual() const {
    return nullptr;
  }
  inline void* MaybeArenaPtr() const {
    return nullptr;
  }
  public:

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

  public:

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

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

  enum : int {
    kComInterfaceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
  bool has_cominterface() const;
  private:
  bool _internal_has_cominterface() const;
  public:
  void clear_cominterface();
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* release_cominterface();
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* mutable_cominterface();
  void set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& _internal_cominterface() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* _internal_mutable_cominterface();
  public:

  // @@protoc_insertion_point(class_scope:OpenTestSystem.OtxDiagManager.Common.IsInterfaceConnectedPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_ComInterfaceCommandsPb_2eproto;
};
// ===================================================================


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

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

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool ActivateEthernetPb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool ActivateEthernetPb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& ActivateEthernetPb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& ActivateEthernetPb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.ActivateEthernetPb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* ActivateEthernetPb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.ActivateEthernetPb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* ActivateEthernetPb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* ActivateEthernetPb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.ActivateEthernetPb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void ActivateEthernetPb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.ActivateEthernetPb.ComInterface)
}

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

// CloseComInterfacePb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool CloseComInterfacePb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool CloseComInterfacePb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& CloseComInterfacePb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& CloseComInterfacePb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CloseComInterfacePb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* CloseComInterfacePb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CloseComInterfacePb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* CloseComInterfacePb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* CloseComInterfacePb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CloseComInterfacePb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void CloseComInterfacePb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CloseComInterfacePb.ComInterface)
}

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

// ConnectComInterfacePb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool ConnectComInterfacePb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool ConnectComInterfacePb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& ConnectComInterfacePb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& ConnectComInterfacePb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.ConnectComInterfacePb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* ConnectComInterfacePb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.ConnectComInterfacePb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* ConnectComInterfacePb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* ConnectComInterfacePb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.ConnectComInterfacePb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void ConnectComInterfacePb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.ConnectComInterfacePb.ComInterface)
}

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

// DeactivateEthernetPb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool DeactivateEthernetPb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool DeactivateEthernetPb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& DeactivateEthernetPb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& DeactivateEthernetPb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DeactivateEthernetPb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* DeactivateEthernetPb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DeactivateEthernetPb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* DeactivateEthernetPb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* DeactivateEthernetPb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DeactivateEthernetPb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void DeactivateEthernetPb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DeactivateEthernetPb.ComInterface)
}

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

// CreateComChannelFromComInterfacePb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool CreateComChannelFromComInterfacePb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool CreateComChannelFromComInterfacePb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& CreateComChannelFromComInterfacePb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& CreateComChannelFromComInterfacePb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* CreateComChannelFromComInterfacePb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* CreateComChannelFromComInterfacePb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* CreateComChannelFromComInterfacePb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void CreateComChannelFromComInterfacePb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.ComInterface)
}

// string Identifier = 2;
inline void CreateComChannelFromComInterfacePb::clear_identifier() {
  identifier_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CreateComChannelFromComInterfacePb::identifier() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Identifier)
  return _internal_identifier();
}
inline void CreateComChannelFromComInterfacePb::set_identifier(const std::string& value) {
  _internal_set_identifier(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Identifier)
}
inline std::string* CreateComChannelFromComInterfacePb::mutable_identifier() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Identifier)
  return _internal_mutable_identifier();
}
inline const std::string& CreateComChannelFromComInterfacePb::_internal_identifier() const {
  return identifier_.GetNoArena();
}
inline void CreateComChannelFromComInterfacePb::_internal_set_identifier(const std::string& value) {
  
  identifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void CreateComChannelFromComInterfacePb::set_identifier(std::string&& value) {
  
  identifier_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Identifier)
}
inline void CreateComChannelFromComInterfacePb::set_identifier(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  identifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Identifier)
}
inline void CreateComChannelFromComInterfacePb::set_identifier(const char* value, size_t size) {
  
  identifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Identifier)
}
inline std::string* CreateComChannelFromComInterfacePb::_internal_mutable_identifier() {
  
  return identifier_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CreateComChannelFromComInterfacePb::release_identifier() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Identifier)
  
  return identifier_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CreateComChannelFromComInterfacePb::set_allocated_identifier(std::string* identifier) {
  if (identifier != nullptr) {
    
  } else {
    
  }
  identifier_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), identifier);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Identifier)
}

// string EcuVariantName = 3;
inline void CreateComChannelFromComInterfacePb::clear_ecuvariantname() {
  ecuvariantname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CreateComChannelFromComInterfacePb::ecuvariantname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.EcuVariantName)
  return _internal_ecuvariantname();
}
inline void CreateComChannelFromComInterfacePb::set_ecuvariantname(const std::string& value) {
  _internal_set_ecuvariantname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.EcuVariantName)
}
inline std::string* CreateComChannelFromComInterfacePb::mutable_ecuvariantname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.EcuVariantName)
  return _internal_mutable_ecuvariantname();
}
inline const std::string& CreateComChannelFromComInterfacePb::_internal_ecuvariantname() const {
  return ecuvariantname_.GetNoArena();
}
inline void CreateComChannelFromComInterfacePb::_internal_set_ecuvariantname(const std::string& value) {
  
  ecuvariantname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void CreateComChannelFromComInterfacePb::set_ecuvariantname(std::string&& value) {
  
  ecuvariantname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.EcuVariantName)
}
inline void CreateComChannelFromComInterfacePb::set_ecuvariantname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  ecuvariantname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.EcuVariantName)
}
inline void CreateComChannelFromComInterfacePb::set_ecuvariantname(const char* value, size_t size) {
  
  ecuvariantname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.EcuVariantName)
}
inline std::string* CreateComChannelFromComInterfacePb::_internal_mutable_ecuvariantname() {
  
  return ecuvariantname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CreateComChannelFromComInterfacePb::release_ecuvariantname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.EcuVariantName)
  
  return ecuvariantname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CreateComChannelFromComInterfacePb::set_allocated_ecuvariantname(std::string* ecuvariantname) {
  if (ecuvariantname != nullptr) {
    
  } else {
    
  }
  ecuvariantname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ecuvariantname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.EcuVariantName)
}

// string Resource = 4;
inline void CreateComChannelFromComInterfacePb::clear_resource() {
  resource_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CreateComChannelFromComInterfacePb::resource() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Resource)
  return _internal_resource();
}
inline void CreateComChannelFromComInterfacePb::set_resource(const std::string& value) {
  _internal_set_resource(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Resource)
}
inline std::string* CreateComChannelFromComInterfacePb::mutable_resource() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Resource)
  return _internal_mutable_resource();
}
inline const std::string& CreateComChannelFromComInterfacePb::_internal_resource() const {
  return resource_.GetNoArena();
}
inline void CreateComChannelFromComInterfacePb::_internal_set_resource(const std::string& value) {
  
  resource_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void CreateComChannelFromComInterfacePb::set_resource(std::string&& value) {
  
  resource_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Resource)
}
inline void CreateComChannelFromComInterfacePb::set_resource(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  resource_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Resource)
}
inline void CreateComChannelFromComInterfacePb::set_resource(const char* value, size_t size) {
  
  resource_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Resource)
}
inline std::string* CreateComChannelFromComInterfacePb::_internal_mutable_resource() {
  
  return resource_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CreateComChannelFromComInterfacePb::release_resource() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Resource)
  
  return resource_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CreateComChannelFromComInterfacePb::set_allocated_resource(std::string* resource) {
  if (resource != nullptr) {
    
  } else {
    
  }
  resource_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), resource);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateComChannelFromComInterfacePb.Resource)
}

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

// GetBatteryVoltageFromComInterfacePb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool GetBatteryVoltageFromComInterfacePb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool GetBatteryVoltageFromComInterfacePb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetBatteryVoltageFromComInterfacePb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetBatteryVoltageFromComInterfacePb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetBatteryVoltageFromComInterfacePb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetBatteryVoltageFromComInterfacePb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetBatteryVoltageFromComInterfacePb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetBatteryVoltageFromComInterfacePb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetBatteryVoltageFromComInterfacePb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetBatteryVoltageFromComInterfacePb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void GetBatteryVoltageFromComInterfacePb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetBatteryVoltageFromComInterfacePb.ComInterface)
}

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

// GetComChannelFromComInterfacePb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool GetComChannelFromComInterfacePb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool GetComChannelFromComInterfacePb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetComChannelFromComInterfacePb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetComChannelFromComInterfacePb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComChannelFromComInterfacePb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComChannelFromComInterfacePb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComChannelFromComInterfacePb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void GetComChannelFromComInterfacePb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.ComInterface)
}

// string Identifier = 2;
inline void GetComChannelFromComInterfacePb::clear_identifier() {
  identifier_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetComChannelFromComInterfacePb::identifier() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Identifier)
  return _internal_identifier();
}
inline void GetComChannelFromComInterfacePb::set_identifier(const std::string& value) {
  _internal_set_identifier(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Identifier)
}
inline std::string* GetComChannelFromComInterfacePb::mutable_identifier() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Identifier)
  return _internal_mutable_identifier();
}
inline const std::string& GetComChannelFromComInterfacePb::_internal_identifier() const {
  return identifier_.GetNoArena();
}
inline void GetComChannelFromComInterfacePb::_internal_set_identifier(const std::string& value) {
  
  identifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetComChannelFromComInterfacePb::set_identifier(std::string&& value) {
  
  identifier_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Identifier)
}
inline void GetComChannelFromComInterfacePb::set_identifier(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  identifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Identifier)
}
inline void GetComChannelFromComInterfacePb::set_identifier(const char* value, size_t size) {
  
  identifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Identifier)
}
inline std::string* GetComChannelFromComInterfacePb::_internal_mutable_identifier() {
  
  return identifier_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetComChannelFromComInterfacePb::release_identifier() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Identifier)
  
  return identifier_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetComChannelFromComInterfacePb::set_allocated_identifier(std::string* identifier) {
  if (identifier != nullptr) {
    
  } else {
    
  }
  identifier_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), identifier);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Identifier)
}

// string EcuVariantName = 3;
inline void GetComChannelFromComInterfacePb::clear_ecuvariantname() {
  ecuvariantname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetComChannelFromComInterfacePb::ecuvariantname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.EcuVariantName)
  return _internal_ecuvariantname();
}
inline void GetComChannelFromComInterfacePb::set_ecuvariantname(const std::string& value) {
  _internal_set_ecuvariantname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.EcuVariantName)
}
inline std::string* GetComChannelFromComInterfacePb::mutable_ecuvariantname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.EcuVariantName)
  return _internal_mutable_ecuvariantname();
}
inline const std::string& GetComChannelFromComInterfacePb::_internal_ecuvariantname() const {
  return ecuvariantname_.GetNoArena();
}
inline void GetComChannelFromComInterfacePb::_internal_set_ecuvariantname(const std::string& value) {
  
  ecuvariantname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetComChannelFromComInterfacePb::set_ecuvariantname(std::string&& value) {
  
  ecuvariantname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.EcuVariantName)
}
inline void GetComChannelFromComInterfacePb::set_ecuvariantname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  ecuvariantname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.EcuVariantName)
}
inline void GetComChannelFromComInterfacePb::set_ecuvariantname(const char* value, size_t size) {
  
  ecuvariantname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.EcuVariantName)
}
inline std::string* GetComChannelFromComInterfacePb::_internal_mutable_ecuvariantname() {
  
  return ecuvariantname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetComChannelFromComInterfacePb::release_ecuvariantname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.EcuVariantName)
  
  return ecuvariantname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetComChannelFromComInterfacePb::set_allocated_ecuvariantname(std::string* ecuvariantname) {
  if (ecuvariantname != nullptr) {
    
  } else {
    
  }
  ecuvariantname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ecuvariantname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.EcuVariantName)
}

// bool PerformVariantSelection = 4;
inline void GetComChannelFromComInterfacePb::clear_performvariantselection() {
  performvariantselection_ = false;
}
inline bool GetComChannelFromComInterfacePb::_internal_performvariantselection() const {
  return performvariantselection_;
}
inline bool GetComChannelFromComInterfacePb::performvariantselection() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.PerformVariantSelection)
  return _internal_performvariantselection();
}
inline void GetComChannelFromComInterfacePb::_internal_set_performvariantselection(bool value) {
  
  performvariantselection_ = value;
}
inline void GetComChannelFromComInterfacePb::set_performvariantselection(bool value) {
  _internal_set_performvariantselection(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.PerformVariantSelection)
}

// string Resource = 5;
inline void GetComChannelFromComInterfacePb::clear_resource() {
  resource_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetComChannelFromComInterfacePb::resource() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Resource)
  return _internal_resource();
}
inline void GetComChannelFromComInterfacePb::set_resource(const std::string& value) {
  _internal_set_resource(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Resource)
}
inline std::string* GetComChannelFromComInterfacePb::mutable_resource() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Resource)
  return _internal_mutable_resource();
}
inline const std::string& GetComChannelFromComInterfacePb::_internal_resource() const {
  return resource_.GetNoArena();
}
inline void GetComChannelFromComInterfacePb::_internal_set_resource(const std::string& value) {
  
  resource_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetComChannelFromComInterfacePb::set_resource(std::string&& value) {
  
  resource_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Resource)
}
inline void GetComChannelFromComInterfacePb::set_resource(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  resource_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Resource)
}
inline void GetComChannelFromComInterfacePb::set_resource(const char* value, size_t size) {
  
  resource_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Resource)
}
inline std::string* GetComChannelFromComInterfacePb::_internal_mutable_resource() {
  
  return resource_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetComChannelFromComInterfacePb::release_resource() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Resource)
  
  return resource_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetComChannelFromComInterfacePb::set_allocated_resource(std::string* resource) {
  if (resource != nullptr) {
    
  } else {
    
  }
  resource_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), resource);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComChannelFromComInterfacePb.Resource)
}

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

// GetComInterfacePb

// string ComInterfaceName = 1;
inline void GetComInterfacePb::clear_cominterfacename() {
  cominterfacename_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetComInterfacePb::cominterfacename() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePb.ComInterfaceName)
  return _internal_cominterfacename();
}
inline void GetComInterfacePb::set_cominterfacename(const std::string& value) {
  _internal_set_cominterfacename(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePb.ComInterfaceName)
}
inline std::string* GetComInterfacePb::mutable_cominterfacename() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePb.ComInterfaceName)
  return _internal_mutable_cominterfacename();
}
inline const std::string& GetComInterfacePb::_internal_cominterfacename() const {
  return cominterfacename_.GetNoArena();
}
inline void GetComInterfacePb::_internal_set_cominterfacename(const std::string& value) {
  
  cominterfacename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetComInterfacePb::set_cominterfacename(std::string&& value) {
  
  cominterfacename_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePb.ComInterfaceName)
}
inline void GetComInterfacePb::set_cominterfacename(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  cominterfacename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePb.ComInterfaceName)
}
inline void GetComInterfacePb::set_cominterfacename(const char* value, size_t size) {
  
  cominterfacename_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePb.ComInterfaceName)
}
inline std::string* GetComInterfacePb::_internal_mutable_cominterfacename() {
  
  return cominterfacename_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetComInterfacePb::release_cominterfacename() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePb.ComInterfaceName)
  
  return cominterfacename_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetComInterfacePb::set_allocated_cominterfacename(std::string* cominterfacename) {
  if (cominterfacename != nullptr) {
    
  } else {
    
  }
  cominterfacename_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), cominterfacename);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePb.ComInterfaceName)
}

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

// GetComInterfaceNameListPb

// .OpenTestSystem.OtxDiagManager.Common.DConnectionStatesPb ConnectionStates = 1;
inline bool GetComInterfaceNameListPb::_internal_has_connectionstates() const {
  return kind_case() == kConnectionStates;
}
inline void GetComInterfaceNameListPb::set_has_connectionstates() {
  _oneof_case_[0] = kConnectionStates;
}
inline void GetComInterfaceNameListPb::clear_connectionstates() {
  if (_internal_has_connectionstates()) {
    kind_.connectionstates_ = 0;
    clear_has_kind();
  }
}
inline ::OpenTestSystem::OtxDiagManager::Common::DConnectionStatesPb GetComInterfaceNameListPb::_internal_connectionstates() const {
  if (_internal_has_connectionstates()) {
    return static_cast< ::OpenTestSystem::OtxDiagManager::Common::DConnectionStatesPb >(kind_.connectionstates_);
  }
  return static_cast< ::OpenTestSystem::OtxDiagManager::Common::DConnectionStatesPb >(0);
}
inline ::OpenTestSystem::OtxDiagManager::Common::DConnectionStatesPb GetComInterfaceNameListPb::connectionstates() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListPb.ConnectionStates)
  return _internal_connectionstates();
}
inline void GetComInterfaceNameListPb::_internal_set_connectionstates(::OpenTestSystem::OtxDiagManager::Common::DConnectionStatesPb value) {
  if (!_internal_has_connectionstates()) {
    clear_kind();
    set_has_connectionstates();
  }
  kind_.connectionstates_ = value;
}
inline void GetComInterfaceNameListPb::set_connectionstates(::OpenTestSystem::OtxDiagManager::Common::DConnectionStatesPb value) {
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListPb.ConnectionStates)
  _internal_set_connectionstates(value);
}

inline bool GetComInterfaceNameListPb::has_kind() const {
  return kind_case() != KIND_NOT_SET;
}
inline void GetComInterfaceNameListPb::clear_has_kind() {
  _oneof_case_[0] = KIND_NOT_SET;
}
inline GetComInterfaceNameListPb::KindCase GetComInterfaceNameListPb::kind_case() const {
  return GetComInterfaceNameListPb::KindCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------

// GetComInterfaceNameListFromEthernetPb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool GetComInterfaceNameListFromEthernetPb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool GetComInterfaceNameListFromEthernetPb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetComInterfaceNameListFromEthernetPb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetComInterfaceNameListFromEthernetPb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComInterfaceNameListFromEthernetPb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComInterfaceNameListFromEthernetPb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComInterfaceNameListFromEthernetPb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void GetComInterfaceNameListFromEthernetPb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.ComInterface)
}

// string OptionString = 2;
inline void GetComInterfaceNameListFromEthernetPb::clear_optionstring() {
  optionstring_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetComInterfaceNameListFromEthernetPb::optionstring() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.OptionString)
  return _internal_optionstring();
}
inline void GetComInterfaceNameListFromEthernetPb::set_optionstring(const std::string& value) {
  _internal_set_optionstring(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.OptionString)
}
inline std::string* GetComInterfaceNameListFromEthernetPb::mutable_optionstring() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.OptionString)
  return _internal_mutable_optionstring();
}
inline const std::string& GetComInterfaceNameListFromEthernetPb::_internal_optionstring() const {
  return optionstring_.GetNoArena();
}
inline void GetComInterfaceNameListFromEthernetPb::_internal_set_optionstring(const std::string& value) {
  
  optionstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetComInterfaceNameListFromEthernetPb::set_optionstring(std::string&& value) {
  
  optionstring_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.OptionString)
}
inline void GetComInterfaceNameListFromEthernetPb::set_optionstring(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  optionstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.OptionString)
}
inline void GetComInterfaceNameListFromEthernetPb::set_optionstring(const char* value, size_t size) {
  
  optionstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.OptionString)
}
inline std::string* GetComInterfaceNameListFromEthernetPb::_internal_mutable_optionstring() {
  
  return optionstring_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetComInterfaceNameListFromEthernetPb::release_optionstring() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.OptionString)
  
  return optionstring_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetComInterfaceNameListFromEthernetPb::set_allocated_optionstring(std::string* optionstring) {
  if (optionstring != nullptr) {
    
  } else {
    
  }
  optionstring_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), optionstring);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceNameListFromEthernetPb.OptionString)
}

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

// GetComInterfacePropertiesPb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool GetComInterfacePropertiesPb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool GetComInterfacePropertiesPb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetComInterfacePropertiesPb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetComInterfacePropertiesPb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePropertiesPb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComInterfacePropertiesPb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePropertiesPb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComInterfacePropertiesPb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComInterfacePropertiesPb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePropertiesPb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void GetComInterfacePropertiesPb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComInterfacePropertiesPb.ComInterface)
}

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

// GetComInterfaceResourceNameListPb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool GetComInterfaceResourceNameListPb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool GetComInterfaceResourceNameListPb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetComInterfaceResourceNameListPb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetComInterfaceResourceNameListPb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceResourceNameListPb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComInterfaceResourceNameListPb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceResourceNameListPb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComInterfaceResourceNameListPb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetComInterfaceResourceNameListPb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceResourceNameListPb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void GetComInterfaceResourceNameListPb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComInterfaceResourceNameListPb.ComInterface)
}

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

// GetDefaultComInterfaceNamePb

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

// GetIgnitionStateFromComInterfacePb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool GetIgnitionStateFromComInterfacePb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool GetIgnitionStateFromComInterfacePb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetIgnitionStateFromComInterfacePb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& GetIgnitionStateFromComInterfacePb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStateFromComInterfacePb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetIgnitionStateFromComInterfacePb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStateFromComInterfacePb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetIgnitionStateFromComInterfacePb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* GetIgnitionStateFromComInterfacePb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStateFromComInterfacePb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void GetIgnitionStateFromComInterfacePb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetIgnitionStateFromComInterfacePb.ComInterface)
}

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

// IsEthernetActivatedPb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool IsEthernetActivatedPb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool IsEthernetActivatedPb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& IsEthernetActivatedPb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& IsEthernetActivatedPb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.IsEthernetActivatedPb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* IsEthernetActivatedPb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.IsEthernetActivatedPb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* IsEthernetActivatedPb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* IsEthernetActivatedPb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.IsEthernetActivatedPb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void IsEthernetActivatedPb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.IsEthernetActivatedPb.ComInterface)
}

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

// IsInterfaceConnectedPb

// .OpenTestSystem.OtxDiagManager.Common.DComInterfacePb ComInterface = 1;
inline bool IsInterfaceConnectedPb::_internal_has_cominterface() const {
  return this != internal_default_instance() && cominterface_ != nullptr;
}
inline bool IsInterfaceConnectedPb::has_cominterface() const {
  return _internal_has_cominterface();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& IsInterfaceConnectedPb::_internal_cominterface() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* p = cominterface_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComInterfacePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb& IsInterfaceConnectedPb::cominterface() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.IsInterfaceConnectedPb.ComInterface)
  return _internal_cominterface();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* IsInterfaceConnectedPb::release_cominterface() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.IsInterfaceConnectedPb.ComInterface)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* temp = cominterface_;
  cominterface_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* IsInterfaceConnectedPb::_internal_mutable_cominterface() {
  
  if (cominterface_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb>(GetArenaNoVirtual());
    cominterface_ = p;
  }
  return cominterface_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* IsInterfaceConnectedPb::mutable_cominterface() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.IsInterfaceConnectedPb.ComInterface)
  return _internal_mutable_cominterface();
}
inline void IsInterfaceConnectedPb::set_allocated_cominterface(::OpenTestSystem::OtxDiagManager::Common::DComInterfacePb* cominterface) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(cominterface_);
  }
  if (cominterface) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      cominterface = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, cominterface, submessage_arena);
    }
    
  } else {
    
  }
  cominterface_ = cominterface;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.IsInterfaceConnectedPb.ComInterface)
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


// @@protoc_insertion_point(namespace_scope)

}  // namespace Common
}  // namespace OtxDiagManager
}  // namespace OpenTestSystem

// @@protoc_insertion_point(global_scope)

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