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

#ifndef GOOGLE_PROTOBUF_INCLUDED_DiagComCommandsPb_2eproto
#define GOOGLE_PROTOBUF_INCLUDED_DiagComCommandsPb_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 "DiagComDataModelsPb.pb.h"
// @@protoc_insertion_point(includes)
#include <google/protobuf/port_def.inc>
#define PROTOBUF_INTERNAL_EXPORT_DiagComCommandsPb_2eproto
PROTOBUF_NAMESPACE_OPEN
namespace internal {
class AnyMetadata;
}  // namespace internal
PROTOBUF_NAMESPACE_CLOSE

// Internal implementation detail -- do not use these members.
struct TableStruct_DiagComCommandsPb_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[31]
    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_DiagComCommandsPb_2eproto;
namespace OpenTestSystem {
namespace OtxDiagManager {
namespace Common {
class CloseComChannelPb;
class CloseComChannelPbDefaultTypeInternal;
extern CloseComChannelPbDefaultTypeInternal _CloseComChannelPb_default_instance_;
class CreateDiagServiceByNamePb;
class CreateDiagServiceByNamePbDefaultTypeInternal;
extern CreateDiagServiceByNamePbDefaultTypeInternal _CreateDiagServiceByNamePb_default_instance_;
class CreateDiagServiceBySemanticPb;
class CreateDiagServiceBySemanticPbDefaultTypeInternal;
extern CreateDiagServiceBySemanticPbDefaultTypeInternal _CreateDiagServiceBySemanticPb_default_instance_;
class ExecuteDiagServicePb;
class ExecuteDiagServicePbDefaultTypeInternal;
extern ExecuteDiagServicePbDefaultTypeInternal _ExecuteDiagServicePb_default_instance_;
class ExecuteHexDiagServicePb;
class ExecuteHexDiagServicePbDefaultTypeInternal;
extern ExecuteHexDiagServicePbDefaultTypeInternal _ExecuteHexDiagServicePb_default_instance_;
class GetComChannelEcuVariantNamePb;
class GetComChannelEcuVariantNamePbDefaultTypeInternal;
extern GetComChannelEcuVariantNamePbDefaultTypeInternal _GetComChannelEcuVariantNamePb_default_instance_;
class GetComChannelPb;
class GetComChannelPbDefaultTypeInternal;
extern GetComChannelPbDefaultTypeInternal _GetComChannelPb_default_instance_;
class GetComParameterValuePb;
class GetComParameterValuePbDefaultTypeInternal;
extern GetComParameterValuePbDefaultTypeInternal _GetComParameterValuePb_default_instance_;
class GetComplexComParameterPb;
class GetComplexComParameterPbDefaultTypeInternal;
extern GetComplexComParameterPbDefaultTypeInternal _GetComplexComParameterPb_default_instance_;
class GetDefaultComParameterValuePb;
class GetDefaultComParameterValuePbDefaultTypeInternal;
extern GetDefaultComParameterValuePbDefaultTypeInternal _GetDefaultComParameterValuePb_default_instance_;
class GetDefaultComplexComParameterPb;
class GetDefaultComplexComParameterPbDefaultTypeInternal;
extern GetDefaultComplexComParameterPbDefaultTypeInternal _GetDefaultComplexComParameterPb_default_instance_;
class GetDiagServiceListBySemanticPb;
class GetDiagServiceListBySemanticPbDefaultTypeInternal;
extern GetDiagServiceListBySemanticPbDefaultTypeInternal _GetDiagServiceListBySemanticPb_default_instance_;
class GetParameterAsListPb;
class GetParameterAsListPbDefaultTypeInternal;
extern GetParameterAsListPbDefaultTypeInternal _GetParameterAsListPb_default_instance_;
class GetParameterByPathPb;
class GetParameterByPathPbDefaultTypeInternal;
extern GetParameterByPathPbDefaultTypeInternal _GetParameterByPathPb_default_instance_;
class GetParameterBySemanticPb;
class GetParameterBySemanticPbDefaultTypeInternal;
extern GetParameterBySemanticPbDefaultTypeInternal _GetParameterBySemanticPb_default_instance_;
class GetParameterValuePb;
class GetParameterValuePbDefaultTypeInternal;
extern GetParameterValuePbDefaultTypeInternal _GetParameterValuePb_default_instance_;
class GetPduPb;
class GetPduPbDefaultTypeInternal;
extern GetPduPbDefaultTypeInternal _GetPduPb_default_instance_;
class GetRepetitionTimePb;
class GetRepetitionTimePbDefaultTypeInternal;
extern GetRepetitionTimePbDefaultTypeInternal _GetRepetitionTimePb_default_instance_;
class GetRequestPb;
class GetRequestPbDefaultTypeInternal;
extern GetRequestPbDefaultTypeInternal _GetRequestPb_default_instance_;
class IdentifyAndSelectVariantPb;
class IdentifyAndSelectVariantPbDefaultTypeInternal;
extern IdentifyAndSelectVariantPbDefaultTypeInternal _IdentifyAndSelectVariantPb_default_instance_;
class OnPrimitiveBufferHasResultPb;
class OnPrimitiveBufferHasResultPbDefaultTypeInternal;
extern OnPrimitiveBufferHasResultPbDefaultTypeInternal _OnPrimitiveBufferHasResultPb_default_instance_;
class OnPrimitiveHasResultPb;
class OnPrimitiveHasResultPbDefaultTypeInternal;
extern OnPrimitiveHasResultPbDefaultTypeInternal _OnPrimitiveHasResultPb_default_instance_;
class OnPrimitiveTerminatedPb;
class OnPrimitiveTerminatedPbDefaultTypeInternal;
extern OnPrimitiveTerminatedPbDefaultTypeInternal _OnPrimitiveTerminatedPb_default_instance_;
class SetComParameterPb;
class SetComParameterPbDefaultTypeInternal;
extern SetComParameterPbDefaultTypeInternal _SetComParameterPb_default_instance_;
class SetComplexComParameterPb;
class SetComplexComParameterPbDefaultTypeInternal;
extern SetComplexComParameterPbDefaultTypeInternal _SetComplexComParameterPb_default_instance_;
class SetParameterValueBySemanticPb;
class SetParameterValueBySemanticPbDefaultTypeInternal;
extern SetParameterValueBySemanticPbDefaultTypeInternal _SetParameterValueBySemanticPb_default_instance_;
class SetParameterValuePb;
class SetParameterValuePbDefaultTypeInternal;
extern SetParameterValuePbDefaultTypeInternal _SetParameterValuePb_default_instance_;
class SetPduPb;
class SetPduPbDefaultTypeInternal;
extern SetPduPbDefaultTypeInternal _SetPduPb_default_instance_;
class SetRepetitionTimePb;
class SetRepetitionTimePbDefaultTypeInternal;
extern SetRepetitionTimePbDefaultTypeInternal _SetRepetitionTimePb_default_instance_;
class StartRepeatedExecutionPb;
class StartRepeatedExecutionPbDefaultTypeInternal;
extern StartRepeatedExecutionPbDefaultTypeInternal _StartRepeatedExecutionPb_default_instance_;
class StopRepeatedExecutionPb;
class StopRepeatedExecutionPbDefaultTypeInternal;
extern StopRepeatedExecutionPbDefaultTypeInternal _StopRepeatedExecutionPb_default_instance_;
}  // namespace Common
}  // namespace OtxDiagManager
}  // namespace OpenTestSystem
PROTOBUF_NAMESPACE_OPEN
template<> ::OpenTestSystem::OtxDiagManager::Common::CloseComChannelPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::CloseComChannelPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::CreateDiagServiceByNamePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::CreateDiagServiceByNamePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::CreateDiagServiceBySemanticPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::CreateDiagServiceBySemanticPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::ExecuteDiagServicePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::ExecuteDiagServicePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::ExecuteHexDiagServicePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::ExecuteHexDiagServicePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetComChannelEcuVariantNamePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetComChannelEcuVariantNamePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetComChannelPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetComChannelPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetComParameterValuePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetComParameterValuePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetComplexComParameterPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetComplexComParameterPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetDefaultComParameterValuePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetDefaultComParameterValuePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetDefaultComplexComParameterPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetDefaultComplexComParameterPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetDiagServiceListBySemanticPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetDiagServiceListBySemanticPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetParameterAsListPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetParameterAsListPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetParameterByPathPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetParameterByPathPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetParameterBySemanticPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetParameterBySemanticPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetParameterValuePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetParameterValuePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetPduPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetPduPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetRepetitionTimePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetRepetitionTimePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::GetRequestPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::GetRequestPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::IdentifyAndSelectVariantPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::IdentifyAndSelectVariantPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::OnPrimitiveBufferHasResultPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::OnPrimitiveBufferHasResultPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::OnPrimitiveHasResultPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::OnPrimitiveHasResultPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::OnPrimitiveTerminatedPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::OnPrimitiveTerminatedPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::SetComParameterPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::SetComParameterPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::SetComplexComParameterPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::SetComplexComParameterPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::SetParameterValueBySemanticPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::SetParameterValueBySemanticPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::SetParameterValuePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::SetParameterValuePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::SetPduPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::SetPduPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::SetRepetitionTimePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::SetRepetitionTimePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::StartRepeatedExecutionPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::StartRepeatedExecutionPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::StopRepeatedExecutionPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::StopRepeatedExecutionPb>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace OpenTestSystem {
namespace OtxDiagManager {
namespace Common {

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

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

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

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

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

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

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

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

  GetComChannelPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetComChannelPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetComChannelPb& from);
  void MergeFrom(const GetComChannelPb& 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(GetComChannelPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetComChannelPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kIdentifierFieldNumber = 1,
    kEcuVariantNameFieldNumber = 2,
    kPerformVariantSelectionFieldNumber = 3,
  };
  // string Identifier = 1;
  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 = 2;
  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:

  // bool PerformVariantSelection = 3;
  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.GetComChannelPb)
 private:
  class _Internal;

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr identifier_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ecuvariantname_;
  bool performvariantselection_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  CreateDiagServiceByNamePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateDiagServiceByNamePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateDiagServiceByNamePb& from);
  void MergeFrom(const CreateDiagServiceByNamePb& 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(CreateDiagServiceByNamePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 2,
    kComChannelFieldNumber = 1,
  };
  // string Name = 2;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  CreateDiagServiceBySemanticPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CreateDiagServiceBySemanticPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CreateDiagServiceBySemanticPb& from);
  void MergeFrom(const CreateDiagServiceBySemanticPb& 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(CreateDiagServiceBySemanticPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSemanticFieldNumber = 2,
    kComChannelFieldNumber = 1,
  };
  // string Semantic = 2;
  void clear_semantic();
  const std::string& semantic() const;
  void set_semantic(const std::string& value);
  void set_semantic(std::string&& value);
  void set_semantic(const char* value);
  void set_semantic(const char* value, size_t size);
  std::string* mutable_semantic();
  std::string* release_semantic();
  void set_allocated_semantic(std::string* semantic);
  private:
  const std::string& _internal_semantic() const;
  void _internal_set_semantic(const std::string& value);
  std::string* _internal_mutable_semantic();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr semantic_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetDiagServiceListBySemanticPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetDiagServiceListBySemanticPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetDiagServiceListBySemanticPb& from);
  void MergeFrom(const GetDiagServiceListBySemanticPb& 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(GetDiagServiceListBySemanticPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSemanticFieldNumber = 2,
    kComChannelFieldNumber = 1,
  };
  // string Semantic = 2;
  void clear_semantic();
  const std::string& semantic() const;
  void set_semantic(const std::string& value);
  void set_semantic(std::string&& value);
  void set_semantic(const char* value);
  void set_semantic(const char* value, size_t size);
  std::string* mutable_semantic();
  std::string* release_semantic();
  void set_allocated_semantic(std::string* semantic);
  private:
  const std::string& _internal_semantic() const;
  void _internal_set_semantic(const std::string& value);
  std::string* _internal_mutable_semantic();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr semantic_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetRepetitionTimePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetRepetitionTimePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetRepetitionTimePb& from);
  void MergeFrom(const GetRepetitionTimePb& 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(GetRepetitionTimePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetRepetitionTimePb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDiagServiceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
  bool has_diagservice() const;
  private:
  bool _internal_has_diagservice() const;
  public:
  void clear_diagservice();
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* release_diagservice();
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* mutable_diagservice();
  void set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& _internal_diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* _internal_mutable_diagservice();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetRequestPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetRequestPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetRequestPb& from);
  void MergeFrom(const GetRequestPb& 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(GetRequestPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetRequestPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDiagServiceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
  bool has_diagservice() const;
  private:
  bool _internal_has_diagservice() const;
  public:
  void clear_diagservice();
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* release_diagservice();
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* mutable_diagservice();
  void set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& _internal_diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* _internal_mutable_diagservice();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetPduPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetPduPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetPduPb& from);
  void MergeFrom(const GetPduPb& 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(GetPduPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetPduPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kRequestFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DRequestPb Request = 1;
  bool has_request() const;
  private:
  bool _internal_has_request() const;
  public:
  void clear_request();
  const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb& request() const;
  ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* release_request();
  ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* mutable_request();
  void set_allocated_request(::OpenTestSystem::OtxDiagManager::Common::DRequestPb* request);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb& _internal_request() const;
  ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* _internal_mutable_request();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* request_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetParameterBySemanticPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetParameterBySemanticPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetParameterBySemanticPb& from);
  void MergeFrom(const GetParameterBySemanticPb& 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(GetParameterBySemanticPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSemanticFieldNumber = 2,
    kParameterContainerFieldNumber = 1,
  };
  // string Semantic = 2;
  void clear_semantic();
  const std::string& semantic() const;
  void set_semantic(const std::string& value);
  void set_semantic(std::string&& value);
  void set_semantic(const char* value);
  void set_semantic(const char* value, size_t size);
  std::string* mutable_semantic();
  std::string* release_semantic();
  void set_allocated_semantic(std::string* semantic);
  private:
  const std::string& _internal_semantic() const;
  void _internal_set_semantic(const std::string& value);
  std::string* _internal_mutable_semantic();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DParameterContainerPb ParameterContainer = 1;
  bool has_parametercontainer() const;
  private:
  bool _internal_has_parametercontainer() const;
  public:
  void clear_parametercontainer();
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& parametercontainer() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* release_parametercontainer();
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* mutable_parametercontainer();
  void set_allocated_parametercontainer(::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& _internal_parametercontainer() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* _internal_mutable_parametercontainer();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr semantic_;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetParameterByPathPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetParameterByPathPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetParameterByPathPb& from);
  void MergeFrom(const GetParameterByPathPb& 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(GetParameterByPathPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPathFieldNumber = 2,
    kParameterContainerFieldNumber = 1,
  };
  // string Path = 2;
  void clear_path();
  const std::string& path() const;
  void set_path(const std::string& value);
  void set_path(std::string&& value);
  void set_path(const char* value);
  void set_path(const char* value, size_t size);
  std::string* mutable_path();
  std::string* release_path();
  void set_allocated_path(std::string* path);
  private:
  const std::string& _internal_path() const;
  void _internal_set_path(const std::string& value);
  std::string* _internal_mutable_path();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DParameterContainerPb ParameterContainer = 1;
  bool has_parametercontainer() const;
  private:
  bool _internal_has_parametercontainer() const;
  public:
  void clear_parametercontainer();
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& parametercontainer() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* release_parametercontainer();
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* mutable_parametercontainer();
  void set_allocated_parametercontainer(::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& _internal_parametercontainer() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* _internal_mutable_parametercontainer();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr path_;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetParameterAsListPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetParameterAsListPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetParameterAsListPb& from);
  void MergeFrom(const GetParameterAsListPb& 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(GetParameterAsListPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetParameterAsListPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kParameterContainerFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DParameterContainerPb ParameterContainer = 1;
  bool has_parametercontainer() const;
  private:
  bool _internal_has_parametercontainer() const;
  public:
  void clear_parametercontainer();
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& parametercontainer() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* release_parametercontainer();
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* mutable_parametercontainer();
  void set_allocated_parametercontainer(::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& _internal_parametercontainer() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* _internal_mutable_parametercontainer();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetParameterValuePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetParameterValuePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetParameterValuePb& from);
  void MergeFrom(const GetParameterValuePb& 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(GetParameterValuePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetParameterValuePb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kParameterFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DParameterPb Parameter = 1;
  bool has_parameter() const;
  private:
  bool _internal_has_parameter() const;
  public:
  void clear_parameter();
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& parameter() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* release_parameter();
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* mutable_parameter();
  void set_allocated_parameter(::OpenTestSystem::OtxDiagManager::Common::DParameterPb* parameter);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& _internal_parameter() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* _internal_mutable_parameter();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* parameter_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetComplexComParameterPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetComplexComParameterPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetComplexComParameterPb& from);
  void MergeFrom(const GetComplexComParameterPb& 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(GetComplexComParameterPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kComParameterNameFieldNumber = 2,
    kComChannelFieldNumber = 1,
  };
  // string ComParameterName = 2;
  void clear_comparametername();
  const std::string& comparametername() const;
  void set_comparametername(const std::string& value);
  void set_comparametername(std::string&& value);
  void set_comparametername(const char* value);
  void set_comparametername(const char* value, size_t size);
  std::string* mutable_comparametername();
  std::string* release_comparametername();
  void set_allocated_comparametername(std::string* comparametername);
  private:
  const std::string& _internal_comparametername() const;
  void _internal_set_comparametername(const std::string& value);
  std::string* _internal_mutable_comparametername();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comparametername_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetComParameterValuePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetComParameterValuePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetComParameterValuePb& from);
  void MergeFrom(const GetComParameterValuePb& 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(GetComParameterValuePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kComParameterNameFieldNumber = 2,
    kComChannelFieldNumber = 1,
    kDataTypeFieldNumber = 3,
  };
  // string ComParameterName = 2;
  void clear_comparametername();
  const std::string& comparametername() const;
  void set_comparametername(const std::string& value);
  void set_comparametername(std::string&& value);
  void set_comparametername(const char* value);
  void set_comparametername(const char* value, size_t size);
  std::string* mutable_comparametername();
  std::string* release_comparametername();
  void set_allocated_comparametername(std::string* comparametername);
  private:
  const std::string& _internal_comparametername() const;
  void _internal_set_comparametername(const std::string& value);
  std::string* _internal_mutable_comparametername();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

  // int32 DataType = 3;
  void clear_datatype();
  ::PROTOBUF_NAMESPACE_ID::int32 datatype() const;
  void set_datatype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_datatype() const;
  void _internal_set_datatype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comparametername_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  ::PROTOBUF_NAMESPACE_ID::int32 datatype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetDefaultComplexComParameterPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetDefaultComplexComParameterPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetDefaultComplexComParameterPb& from);
  void MergeFrom(const GetDefaultComplexComParameterPb& 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(GetDefaultComplexComParameterPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kComParameterNameFieldNumber = 2,
    kComChannelFieldNumber = 1,
  };
  // string ComParameterName = 2;
  void clear_comparametername();
  const std::string& comparametername() const;
  void set_comparametername(const std::string& value);
  void set_comparametername(std::string&& value);
  void set_comparametername(const char* value);
  void set_comparametername(const char* value, size_t size);
  std::string* mutable_comparametername();
  std::string* release_comparametername();
  void set_allocated_comparametername(std::string* comparametername);
  private:
  const std::string& _internal_comparametername() const;
  void _internal_set_comparametername(const std::string& value);
  std::string* _internal_mutable_comparametername();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comparametername_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetDefaultComParameterValuePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetDefaultComParameterValuePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetDefaultComParameterValuePb& from);
  void MergeFrom(const GetDefaultComParameterValuePb& 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(GetDefaultComParameterValuePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kComParameterNameFieldNumber = 2,
    kComChannelFieldNumber = 1,
    kDataTypeFieldNumber = 3,
  };
  // string ComParameterName = 2;
  void clear_comparametername();
  const std::string& comparametername() const;
  void set_comparametername(const std::string& value);
  void set_comparametername(std::string&& value);
  void set_comparametername(const char* value);
  void set_comparametername(const char* value, size_t size);
  std::string* mutable_comparametername();
  std::string* release_comparametername();
  void set_allocated_comparametername(std::string* comparametername);
  private:
  const std::string& _internal_comparametername() const;
  void _internal_set_comparametername(const std::string& value);
  std::string* _internal_mutable_comparametername();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

  // int32 DataType = 3;
  void clear_datatype();
  ::PROTOBUF_NAMESPACE_ID::int32 datatype() const;
  void set_datatype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_datatype() const;
  void _internal_set_datatype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr comparametername_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  ::PROTOBUF_NAMESPACE_ID::int32 datatype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  IdentifyAndSelectVariantPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<IdentifyAndSelectVariantPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const IdentifyAndSelectVariantPb& from);
  void MergeFrom(const IdentifyAndSelectVariantPb& 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(IdentifyAndSelectVariantPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.IdentifyAndSelectVariantPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kComChannelFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  CloseComChannelPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<CloseComChannelPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const CloseComChannelPb& from);
  void MergeFrom(const CloseComChannelPb& 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(CloseComChannelPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.CloseComChannelPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kComChannelFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  SetComParameterPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SetComParameterPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SetComParameterPb& from);
  void MergeFrom(const SetComParameterPb& 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(SetComParameterPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.SetComParameterPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kNameFieldNumber = 2,
    kComChannelFieldNumber = 1,
    kValueFieldNumber = 3,
  };
  // string Name = 2;
  void clear_name();
  const std::string& name() const;
  void set_name(const std::string& value);
  void set_name(std::string&& value);
  void set_name(const char* value);
  void set_name(const char* value, size_t size);
  std::string* mutable_name();
  std::string* release_name();
  void set_allocated_name(std::string* name);
  private:
  const std::string& _internal_name() const;
  void _internal_set_name(const std::string& value);
  std::string* _internal_mutable_name();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DValuePb Value = 3;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& value() const;
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* release_value();
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* mutable_value();
  void set_allocated_value(::OpenTestSystem::OtxDiagManager::Common::DValuePb* value);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& _internal_value() const;
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* _internal_mutable_value();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  SetComplexComParameterPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SetComplexComParameterPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SetComplexComParameterPb& from);
  void MergeFrom(const SetComplexComParameterPb& 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(SetComplexComParameterPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.SetComplexComParameterPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kComChannelFieldNumber = 1,
    kParameterFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DParameterPb Parameter = 2;
  bool has_parameter() const;
  private:
  bool _internal_has_parameter() const;
  public:
  void clear_parameter();
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& parameter() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* release_parameter();
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* mutable_parameter();
  void set_allocated_parameter(::OpenTestSystem::OtxDiagManager::Common::DParameterPb* parameter);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& _internal_parameter() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* _internal_mutable_parameter();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* parameter_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  ExecuteDiagServicePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExecuteDiagServicePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ExecuteDiagServicePb& from);
  void MergeFrom(const ExecuteDiagServicePb& 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(ExecuteDiagServicePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDiagServiceFieldNumber = 1,
    kRequestParamtersFieldNumber = 3,
    kResponseParamtersFieldNumber = 4,
    kSuppressPositiveResponseFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
  bool has_diagservice() const;
  private:
  bool _internal_has_diagservice() const;
  public:
  void clear_diagservice();
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* release_diagservice();
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* mutable_diagservice();
  void set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& _internal_diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* _internal_mutable_diagservice();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DParameterCollectionPb RequestParamters = 3;
  bool has_requestparamters() const;
  private:
  bool _internal_has_requestparamters() const;
  public:
  void clear_requestparamters();
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb& requestparamters() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* release_requestparamters();
  ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* mutable_requestparamters();
  void set_allocated_requestparamters(::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* requestparamters);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb& _internal_requestparamters() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* _internal_mutable_requestparamters();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DParameterCollectionPb ResponseParamters = 4;
  bool has_responseparamters() const;
  private:
  bool _internal_has_responseparamters() const;
  public:
  void clear_responseparamters();
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb& responseparamters() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* release_responseparamters();
  ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* mutable_responseparamters();
  void set_allocated_responseparamters(::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* responseparamters);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb& _internal_responseparamters() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* _internal_mutable_responseparamters();
  public:

  // bool suppressPositiveResponse = 2;
  void clear_suppresspositiveresponse();
  bool suppresspositiveresponse() const;
  void set_suppresspositiveresponse(bool value);
  private:
  bool _internal_suppresspositiveresponse() const;
  void _internal_set_suppresspositiveresponse(bool value);
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice_;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* requestparamters_;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* responseparamters_;
  bool suppresspositiveresponse_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  ExecuteHexDiagServicePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<ExecuteHexDiagServicePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const ExecuteHexDiagServicePb& from);
  void MergeFrom(const ExecuteHexDiagServicePb& 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(ExecuteHexDiagServicePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kHexRequestFieldNumber = 2,
    kComChannelFieldNumber = 1,
  };
  // bytes HexRequest = 2;
  void clear_hexrequest();
  const std::string& hexrequest() const;
  void set_hexrequest(const std::string& value);
  void set_hexrequest(std::string&& value);
  void set_hexrequest(const char* value);
  void set_hexrequest(const void* value, size_t size);
  std::string* mutable_hexrequest();
  std::string* release_hexrequest();
  void set_allocated_hexrequest(std::string* hexrequest);
  private:
  const std::string& _internal_hexrequest() const;
  void _internal_set_hexrequest(const std::string& value);
  std::string* _internal_mutable_hexrequest();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr hexrequest_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  StartRepeatedExecutionPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<StartRepeatedExecutionPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const StartRepeatedExecutionPb& from);
  void MergeFrom(const StartRepeatedExecutionPb& 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(StartRepeatedExecutionPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.StartRepeatedExecutionPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDiagServiceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
  bool has_diagservice() const;
  private:
  bool _internal_has_diagservice() const;
  public:
  void clear_diagservice();
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* release_diagservice();
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* mutable_diagservice();
  void set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& _internal_diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* _internal_mutable_diagservice();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  StopRepeatedExecutionPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<StopRepeatedExecutionPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const StopRepeatedExecutionPb& from);
  void MergeFrom(const StopRepeatedExecutionPb& 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(StopRepeatedExecutionPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.StopRepeatedExecutionPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDiagServiceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
  bool has_diagservice() const;
  private:
  bool _internal_has_diagservice() const;
  public:
  void clear_diagservice();
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* release_diagservice();
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* mutable_diagservice();
  void set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& _internal_diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* _internal_mutable_diagservice();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  SetRepetitionTimePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SetRepetitionTimePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SetRepetitionTimePb& from);
  void MergeFrom(const SetRepetitionTimePb& 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(SetRepetitionTimePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.SetRepetitionTimePb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDiagServiceFieldNumber = 1,
    kRepetitionTimeFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
  bool has_diagservice() const;
  private:
  bool _internal_has_diagservice() const;
  public:
  void clear_diagservice();
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* release_diagservice();
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* mutable_diagservice();
  void set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& _internal_diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* _internal_mutable_diagservice();
  public:

  // double RepetitionTime = 2;
  void clear_repetitiontime();
  double repetitiontime() const;
  void set_repetitiontime(double value);
  private:
  double _internal_repetitiontime() const;
  void _internal_set_repetitiontime(double value);
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice_;
  double repetitiontime_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  SetParameterValuePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SetParameterValuePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SetParameterValuePb& from);
  void MergeFrom(const SetParameterValuePb& 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(SetParameterValuePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.SetParameterValuePb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kParameterFieldNumber = 1,
    kValueFieldNumber = 2,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DParameterPb Parameter = 1;
  bool has_parameter() const;
  private:
  bool _internal_has_parameter() const;
  public:
  void clear_parameter();
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& parameter() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* release_parameter();
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* mutable_parameter();
  void set_allocated_parameter(::OpenTestSystem::OtxDiagManager::Common::DParameterPb* parameter);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& _internal_parameter() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* _internal_mutable_parameter();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DValuePb Value = 2;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& value() const;
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* release_value();
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* mutable_value();
  void set_allocated_value(::OpenTestSystem::OtxDiagManager::Common::DValuePb* value);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& _internal_value() const;
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* _internal_mutable_value();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* parameter_;
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  SetParameterValueBySemanticPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SetParameterValueBySemanticPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SetParameterValueBySemanticPb& from);
  void MergeFrom(const SetParameterValueBySemanticPb& 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(SetParameterValueBySemanticPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kSemanticFieldNumber = 2,
    kParameterContainerFieldNumber = 1,
    kValueFieldNumber = 3,
  };
  // string Semantic = 2;
  void clear_semantic();
  const std::string& semantic() const;
  void set_semantic(const std::string& value);
  void set_semantic(std::string&& value);
  void set_semantic(const char* value);
  void set_semantic(const char* value, size_t size);
  std::string* mutable_semantic();
  std::string* release_semantic();
  void set_allocated_semantic(std::string* semantic);
  private:
  const std::string& _internal_semantic() const;
  void _internal_set_semantic(const std::string& value);
  std::string* _internal_mutable_semantic();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DParameterContainerPb ParameterContainer = 1;
  bool has_parametercontainer() const;
  private:
  bool _internal_has_parametercontainer() const;
  public:
  void clear_parametercontainer();
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& parametercontainer() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* release_parametercontainer();
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* mutable_parametercontainer();
  void set_allocated_parametercontainer(::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& _internal_parametercontainer() const;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* _internal_mutable_parametercontainer();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DValuePb Value = 3;
  bool has_value() const;
  private:
  bool _internal_has_value() const;
  public:
  void clear_value();
  const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& value() const;
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* release_value();
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* mutable_value();
  void set_allocated_value(::OpenTestSystem::OtxDiagManager::Common::DValuePb* value);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& _internal_value() const;
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* _internal_mutable_value();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr semantic_;
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer_;
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* value_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  SetPduPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<SetPduPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const SetPduPb& from);
  void MergeFrom(const SetPduPb& 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(SetPduPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.SetPduPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kPduFieldNumber = 2,
    kRequestFieldNumber = 1,
  };
  // bytes Pdu = 2;
  void clear_pdu();
  const std::string& pdu() const;
  void set_pdu(const std::string& value);
  void set_pdu(std::string&& value);
  void set_pdu(const char* value);
  void set_pdu(const void* value, size_t size);
  std::string* mutable_pdu();
  std::string* release_pdu();
  void set_allocated_pdu(std::string* pdu);
  private:
  const std::string& _internal_pdu() const;
  void _internal_set_pdu(const std::string& value);
  std::string* _internal_mutable_pdu();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DRequestPb Request = 1;
  bool has_request() const;
  private:
  bool _internal_has_request() const;
  public:
  void clear_request();
  const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb& request() const;
  ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* release_request();
  ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* mutable_request();
  void set_allocated_request(::OpenTestSystem::OtxDiagManager::Common::DRequestPb* request);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb& _internal_request() const;
  ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* _internal_mutable_request();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr pdu_;
  ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* request_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  GetComChannelEcuVariantNamePb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<GetComChannelEcuVariantNamePb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const GetComChannelEcuVariantNamePb& from);
  void MergeFrom(const GetComChannelEcuVariantNamePb& 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(GetComChannelEcuVariantNamePb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.GetComChannelEcuVariantNamePb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kComChannelFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
  bool has_comchannel() const;
  private:
  bool _internal_has_comchannel() const;
  public:
  void clear_comchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* release_comchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* mutable_comchannel();
  void set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& _internal_comchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* _internal_mutable_comchannel();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  OnPrimitiveTerminatedPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OnPrimitiveTerminatedPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const OnPrimitiveTerminatedPb& from);
  void MergeFrom(const OnPrimitiveTerminatedPb& 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(OnPrimitiveTerminatedPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.OnPrimitiveTerminatedPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDiagServiceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
  bool has_diagservice() const;
  private:
  bool _internal_has_diagservice() const;
  public:
  void clear_diagservice();
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* release_diagservice();
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* mutable_diagservice();
  void set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& _internal_diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* _internal_mutable_diagservice();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  OnPrimitiveHasResultPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OnPrimitiveHasResultPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const OnPrimitiveHasResultPb& from);
  void MergeFrom(const OnPrimitiveHasResultPb& 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(OnPrimitiveHasResultPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.OnPrimitiveHasResultPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kDiagServiceFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
  bool has_diagservice() const;
  private:
  bool _internal_has_diagservice() const;
  public:
  void clear_diagservice();
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* release_diagservice();
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* mutable_diagservice();
  void set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& _internal_diagservice() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* _internal_mutable_diagservice();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

  OnPrimitiveBufferHasResultPb* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
    return CreateMaybeMessage<OnPrimitiveBufferHasResultPb>(arena);
  }
  void CopyFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void MergeFrom(const ::PROTOBUF_NAMESPACE_ID::Message& from) final;
  void CopyFrom(const OnPrimitiveBufferHasResultPb& from);
  void MergeFrom(const OnPrimitiveBufferHasResultPb& 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(OnPrimitiveBufferHasResultPb* other);
  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
    return "OpenTestSystem.OtxDiagManager.Common.OnPrimitiveBufferHasResultPb";
  }
  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_DiagComCommandsPb_2eproto);
    return ::descriptor_table_DiagComCommandsPb_2eproto.file_level_metadata[kIndexInFileMessages];
  }

  public:

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

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

  enum : int {
    kResultFieldNumber = 1,
  };
  // .OpenTestSystem.OtxDiagManager.Common.DResultPb Result = 1;
  bool has_result() const;
  private:
  bool _internal_has_result() const;
  public:
  void clear_result();
  const ::OpenTestSystem::OtxDiagManager::Common::DResultPb& result() const;
  ::OpenTestSystem::OtxDiagManager::Common::DResultPb* release_result();
  ::OpenTestSystem::OtxDiagManager::Common::DResultPb* mutable_result();
  void set_allocated_result(::OpenTestSystem::OtxDiagManager::Common::DResultPb* result);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DResultPb& _internal_result() const;
  ::OpenTestSystem::OtxDiagManager::Common::DResultPb* _internal_mutable_result();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::OpenTestSystem::OtxDiagManager::Common::DResultPb* result_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_DiagComCommandsPb_2eproto;
};
// ===================================================================


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

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

// string Identifier = 1;
inline void GetComChannelPb::clear_identifier() {
  identifier_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetComChannelPb::identifier() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComChannelPb.Identifier)
  return _internal_identifier();
}
inline void GetComChannelPb::set_identifier(const std::string& value) {
  _internal_set_identifier(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComChannelPb.Identifier)
}
inline std::string* GetComChannelPb::mutable_identifier() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComChannelPb.Identifier)
  return _internal_mutable_identifier();
}
inline const std::string& GetComChannelPb::_internal_identifier() const {
  return identifier_.GetNoArena();
}
inline void GetComChannelPb::_internal_set_identifier(const std::string& value) {
  
  identifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetComChannelPb::set_identifier(std::string&& value) {
  
  identifier_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetComChannelPb.Identifier)
}
inline void GetComChannelPb::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.GetComChannelPb.Identifier)
}
inline void GetComChannelPb::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.GetComChannelPb.Identifier)
}
inline std::string* GetComChannelPb::_internal_mutable_identifier() {
  
  return identifier_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetComChannelPb::release_identifier() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComChannelPb.Identifier)
  
  return identifier_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetComChannelPb::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.GetComChannelPb.Identifier)
}

// string EcuVariantName = 2;
inline void GetComChannelPb::clear_ecuvariantname() {
  ecuvariantname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetComChannelPb::ecuvariantname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComChannelPb.EcuVariantName)
  return _internal_ecuvariantname();
}
inline void GetComChannelPb::set_ecuvariantname(const std::string& value) {
  _internal_set_ecuvariantname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComChannelPb.EcuVariantName)
}
inline std::string* GetComChannelPb::mutable_ecuvariantname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComChannelPb.EcuVariantName)
  return _internal_mutable_ecuvariantname();
}
inline const std::string& GetComChannelPb::_internal_ecuvariantname() const {
  return ecuvariantname_.GetNoArena();
}
inline void GetComChannelPb::_internal_set_ecuvariantname(const std::string& value) {
  
  ecuvariantname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetComChannelPb::set_ecuvariantname(std::string&& value) {
  
  ecuvariantname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetComChannelPb.EcuVariantName)
}
inline void GetComChannelPb::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.GetComChannelPb.EcuVariantName)
}
inline void GetComChannelPb::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.GetComChannelPb.EcuVariantName)
}
inline std::string* GetComChannelPb::_internal_mutable_ecuvariantname() {
  
  return ecuvariantname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetComChannelPb::release_ecuvariantname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComChannelPb.EcuVariantName)
  
  return ecuvariantname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetComChannelPb::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.GetComChannelPb.EcuVariantName)
}

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

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

// CreateDiagServiceByNamePb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool CreateDiagServiceByNamePb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool CreateDiagServiceByNamePb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CreateDiagServiceByNamePb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CreateDiagServiceByNamePb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateDiagServiceByNamePb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateDiagServiceByNamePb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateDiagServiceByNamePb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void CreateDiagServiceByNamePb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.ComChannel)
}

// string Name = 2;
inline void CreateDiagServiceByNamePb::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CreateDiagServiceByNamePb::name() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.Name)
  return _internal_name();
}
inline void CreateDiagServiceByNamePb::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.Name)
}
inline std::string* CreateDiagServiceByNamePb::mutable_name() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.Name)
  return _internal_mutable_name();
}
inline const std::string& CreateDiagServiceByNamePb::_internal_name() const {
  return name_.GetNoArena();
}
inline void CreateDiagServiceByNamePb::_internal_set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void CreateDiagServiceByNamePb::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.Name)
}
inline void CreateDiagServiceByNamePb::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.Name)
}
inline void CreateDiagServiceByNamePb::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.Name)
}
inline std::string* CreateDiagServiceByNamePb::_internal_mutable_name() {
  
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CreateDiagServiceByNamePb::release_name() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.Name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CreateDiagServiceByNamePb::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceByNamePb.Name)
}

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

// CreateDiagServiceBySemanticPb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool CreateDiagServiceBySemanticPb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool CreateDiagServiceBySemanticPb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CreateDiagServiceBySemanticPb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CreateDiagServiceBySemanticPb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateDiagServiceBySemanticPb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateDiagServiceBySemanticPb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CreateDiagServiceBySemanticPb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void CreateDiagServiceBySemanticPb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.ComChannel)
}

// string Semantic = 2;
inline void CreateDiagServiceBySemanticPb::clear_semantic() {
  semantic_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& CreateDiagServiceBySemanticPb::semantic() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.Semantic)
  return _internal_semantic();
}
inline void CreateDiagServiceBySemanticPb::set_semantic(const std::string& value) {
  _internal_set_semantic(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.Semantic)
}
inline std::string* CreateDiagServiceBySemanticPb::mutable_semantic() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.Semantic)
  return _internal_mutable_semantic();
}
inline const std::string& CreateDiagServiceBySemanticPb::_internal_semantic() const {
  return semantic_.GetNoArena();
}
inline void CreateDiagServiceBySemanticPb::_internal_set_semantic(const std::string& value) {
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void CreateDiagServiceBySemanticPb::set_semantic(std::string&& value) {
  
  semantic_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.Semantic)
}
inline void CreateDiagServiceBySemanticPb::set_semantic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.Semantic)
}
inline void CreateDiagServiceBySemanticPb::set_semantic(const char* value, size_t size) {
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.Semantic)
}
inline std::string* CreateDiagServiceBySemanticPb::_internal_mutable_semantic() {
  
  return semantic_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* CreateDiagServiceBySemanticPb::release_semantic() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.Semantic)
  
  return semantic_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void CreateDiagServiceBySemanticPb::set_allocated_semantic(std::string* semantic) {
  if (semantic != nullptr) {
    
  } else {
    
  }
  semantic_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), semantic);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CreateDiagServiceBySemanticPb.Semantic)
}

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

// GetDiagServiceListBySemanticPb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool GetDiagServiceListBySemanticPb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool GetDiagServiceListBySemanticPb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetDiagServiceListBySemanticPb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetDiagServiceListBySemanticPb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetDiagServiceListBySemanticPb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetDiagServiceListBySemanticPb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetDiagServiceListBySemanticPb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void GetDiagServiceListBySemanticPb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.ComChannel)
}

// string Semantic = 2;
inline void GetDiagServiceListBySemanticPb::clear_semantic() {
  semantic_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetDiagServiceListBySemanticPb::semantic() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.Semantic)
  return _internal_semantic();
}
inline void GetDiagServiceListBySemanticPb::set_semantic(const std::string& value) {
  _internal_set_semantic(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.Semantic)
}
inline std::string* GetDiagServiceListBySemanticPb::mutable_semantic() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.Semantic)
  return _internal_mutable_semantic();
}
inline const std::string& GetDiagServiceListBySemanticPb::_internal_semantic() const {
  return semantic_.GetNoArena();
}
inline void GetDiagServiceListBySemanticPb::_internal_set_semantic(const std::string& value) {
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetDiagServiceListBySemanticPb::set_semantic(std::string&& value) {
  
  semantic_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.Semantic)
}
inline void GetDiagServiceListBySemanticPb::set_semantic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.Semantic)
}
inline void GetDiagServiceListBySemanticPb::set_semantic(const char* value, size_t size) {
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.Semantic)
}
inline std::string* GetDiagServiceListBySemanticPb::_internal_mutable_semantic() {
  
  return semantic_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetDiagServiceListBySemanticPb::release_semantic() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.Semantic)
  
  return semantic_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetDiagServiceListBySemanticPb::set_allocated_semantic(std::string* semantic) {
  if (semantic != nullptr) {
    
  } else {
    
  }
  semantic_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), semantic);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetDiagServiceListBySemanticPb.Semantic)
}

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

// GetRepetitionTimePb

// .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
inline bool GetRepetitionTimePb::_internal_has_diagservice() const {
  return this != internal_default_instance() && diagservice_ != nullptr;
}
inline bool GetRepetitionTimePb::has_diagservice() const {
  return _internal_has_diagservice();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& GetRepetitionTimePb::_internal_diagservice() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* p = diagservice_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDiagServicePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& GetRepetitionTimePb::diagservice() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetRepetitionTimePb.DiagService)
  return _internal_diagservice();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* GetRepetitionTimePb::release_diagservice() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetRepetitionTimePb.DiagService)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* temp = diagservice_;
  diagservice_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* GetRepetitionTimePb::_internal_mutable_diagservice() {
  
  if (diagservice_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb>(GetArenaNoVirtual());
    diagservice_ = p;
  }
  return diagservice_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* GetRepetitionTimePb::mutable_diagservice() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetRepetitionTimePb.DiagService)
  return _internal_mutable_diagservice();
}
inline void GetRepetitionTimePb::set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagservice_);
  }
  if (diagservice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      diagservice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, diagservice, submessage_arena);
    }
    
  } else {
    
  }
  diagservice_ = diagservice;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetRepetitionTimePb.DiagService)
}

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

// GetRequestPb

// .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
inline bool GetRequestPb::_internal_has_diagservice() const {
  return this != internal_default_instance() && diagservice_ != nullptr;
}
inline bool GetRequestPb::has_diagservice() const {
  return _internal_has_diagservice();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& GetRequestPb::_internal_diagservice() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* p = diagservice_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDiagServicePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& GetRequestPb::diagservice() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetRequestPb.DiagService)
  return _internal_diagservice();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* GetRequestPb::release_diagservice() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetRequestPb.DiagService)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* temp = diagservice_;
  diagservice_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* GetRequestPb::_internal_mutable_diagservice() {
  
  if (diagservice_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb>(GetArenaNoVirtual());
    diagservice_ = p;
  }
  return diagservice_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* GetRequestPb::mutable_diagservice() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetRequestPb.DiagService)
  return _internal_mutable_diagservice();
}
inline void GetRequestPb::set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagservice_);
  }
  if (diagservice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      diagservice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, diagservice, submessage_arena);
    }
    
  } else {
    
  }
  diagservice_ = diagservice;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetRequestPb.DiagService)
}

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

// GetPduPb

// .OpenTestSystem.OtxDiagManager.Common.DRequestPb Request = 1;
inline bool GetPduPb::_internal_has_request() const {
  return this != internal_default_instance() && request_ != nullptr;
}
inline bool GetPduPb::has_request() const {
  return _internal_has_request();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb& GetPduPb::_internal_request() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* p = request_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DRequestPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb& GetPduPb::request() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetPduPb.Request)
  return _internal_request();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* GetPduPb::release_request() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetPduPb.Request)
  
  ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* temp = request_;
  request_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* GetPduPb::_internal_mutable_request() {
  
  if (request_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DRequestPb>(GetArenaNoVirtual());
    request_ = p;
  }
  return request_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* GetPduPb::mutable_request() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetPduPb.Request)
  return _internal_mutable_request();
}
inline void GetPduPb::set_allocated_request(::OpenTestSystem::OtxDiagManager::Common::DRequestPb* request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_);
  }
  if (request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, request, submessage_arena);
    }
    
  } else {
    
  }
  request_ = request;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetPduPb.Request)
}

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

// GetParameterBySemanticPb

// .OpenTestSystem.OtxDiagManager.Common.DParameterContainerPb ParameterContainer = 1;
inline bool GetParameterBySemanticPb::_internal_has_parametercontainer() const {
  return this != internal_default_instance() && parametercontainer_ != nullptr;
}
inline bool GetParameterBySemanticPb::has_parametercontainer() const {
  return _internal_has_parametercontainer();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& GetParameterBySemanticPb::_internal_parametercontainer() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* p = parametercontainer_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DParameterContainerPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& GetParameterBySemanticPb::parametercontainer() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.ParameterContainer)
  return _internal_parametercontainer();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* GetParameterBySemanticPb::release_parametercontainer() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.ParameterContainer)
  
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* temp = parametercontainer_;
  parametercontainer_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* GetParameterBySemanticPb::_internal_mutable_parametercontainer() {
  
  if (parametercontainer_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb>(GetArenaNoVirtual());
    parametercontainer_ = p;
  }
  return parametercontainer_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* GetParameterBySemanticPb::mutable_parametercontainer() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.ParameterContainer)
  return _internal_mutable_parametercontainer();
}
inline void GetParameterBySemanticPb::set_allocated_parametercontainer(::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(parametercontainer_);
  }
  if (parametercontainer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      parametercontainer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parametercontainer, submessage_arena);
    }
    
  } else {
    
  }
  parametercontainer_ = parametercontainer;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.ParameterContainer)
}

// string Semantic = 2;
inline void GetParameterBySemanticPb::clear_semantic() {
  semantic_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetParameterBySemanticPb::semantic() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.Semantic)
  return _internal_semantic();
}
inline void GetParameterBySemanticPb::set_semantic(const std::string& value) {
  _internal_set_semantic(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.Semantic)
}
inline std::string* GetParameterBySemanticPb::mutable_semantic() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.Semantic)
  return _internal_mutable_semantic();
}
inline const std::string& GetParameterBySemanticPb::_internal_semantic() const {
  return semantic_.GetNoArena();
}
inline void GetParameterBySemanticPb::_internal_set_semantic(const std::string& value) {
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetParameterBySemanticPb::set_semantic(std::string&& value) {
  
  semantic_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.Semantic)
}
inline void GetParameterBySemanticPb::set_semantic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.Semantic)
}
inline void GetParameterBySemanticPb::set_semantic(const char* value, size_t size) {
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.Semantic)
}
inline std::string* GetParameterBySemanticPb::_internal_mutable_semantic() {
  
  return semantic_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetParameterBySemanticPb::release_semantic() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.Semantic)
  
  return semantic_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetParameterBySemanticPb::set_allocated_semantic(std::string* semantic) {
  if (semantic != nullptr) {
    
  } else {
    
  }
  semantic_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), semantic);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetParameterBySemanticPb.Semantic)
}

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

// GetParameterByPathPb

// .OpenTestSystem.OtxDiagManager.Common.DParameterContainerPb ParameterContainer = 1;
inline bool GetParameterByPathPb::_internal_has_parametercontainer() const {
  return this != internal_default_instance() && parametercontainer_ != nullptr;
}
inline bool GetParameterByPathPb::has_parametercontainer() const {
  return _internal_has_parametercontainer();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& GetParameterByPathPb::_internal_parametercontainer() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* p = parametercontainer_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DParameterContainerPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& GetParameterByPathPb::parametercontainer() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.ParameterContainer)
  return _internal_parametercontainer();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* GetParameterByPathPb::release_parametercontainer() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.ParameterContainer)
  
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* temp = parametercontainer_;
  parametercontainer_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* GetParameterByPathPb::_internal_mutable_parametercontainer() {
  
  if (parametercontainer_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb>(GetArenaNoVirtual());
    parametercontainer_ = p;
  }
  return parametercontainer_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* GetParameterByPathPb::mutable_parametercontainer() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.ParameterContainer)
  return _internal_mutable_parametercontainer();
}
inline void GetParameterByPathPb::set_allocated_parametercontainer(::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(parametercontainer_);
  }
  if (parametercontainer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      parametercontainer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parametercontainer, submessage_arena);
    }
    
  } else {
    
  }
  parametercontainer_ = parametercontainer;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.ParameterContainer)
}

// string Path = 2;
inline void GetParameterByPathPb::clear_path() {
  path_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetParameterByPathPb::path() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.Path)
  return _internal_path();
}
inline void GetParameterByPathPb::set_path(const std::string& value) {
  _internal_set_path(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.Path)
}
inline std::string* GetParameterByPathPb::mutable_path() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.Path)
  return _internal_mutable_path();
}
inline const std::string& GetParameterByPathPb::_internal_path() const {
  return path_.GetNoArena();
}
inline void GetParameterByPathPb::_internal_set_path(const std::string& value) {
  
  path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetParameterByPathPb::set_path(std::string&& value) {
  
  path_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.Path)
}
inline void GetParameterByPathPb::set_path(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.Path)
}
inline void GetParameterByPathPb::set_path(const char* value, size_t size) {
  
  path_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.Path)
}
inline std::string* GetParameterByPathPb::_internal_mutable_path() {
  
  return path_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetParameterByPathPb::release_path() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.Path)
  
  return path_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetParameterByPathPb::set_allocated_path(std::string* path) {
  if (path != nullptr) {
    
  } else {
    
  }
  path_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), path);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetParameterByPathPb.Path)
}

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

// GetParameterAsListPb

// .OpenTestSystem.OtxDiagManager.Common.DParameterContainerPb ParameterContainer = 1;
inline bool GetParameterAsListPb::_internal_has_parametercontainer() const {
  return this != internal_default_instance() && parametercontainer_ != nullptr;
}
inline bool GetParameterAsListPb::has_parametercontainer() const {
  return _internal_has_parametercontainer();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& GetParameterAsListPb::_internal_parametercontainer() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* p = parametercontainer_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DParameterContainerPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& GetParameterAsListPb::parametercontainer() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetParameterAsListPb.ParameterContainer)
  return _internal_parametercontainer();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* GetParameterAsListPb::release_parametercontainer() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetParameterAsListPb.ParameterContainer)
  
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* temp = parametercontainer_;
  parametercontainer_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* GetParameterAsListPb::_internal_mutable_parametercontainer() {
  
  if (parametercontainer_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb>(GetArenaNoVirtual());
    parametercontainer_ = p;
  }
  return parametercontainer_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* GetParameterAsListPb::mutable_parametercontainer() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetParameterAsListPb.ParameterContainer)
  return _internal_mutable_parametercontainer();
}
inline void GetParameterAsListPb::set_allocated_parametercontainer(::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(parametercontainer_);
  }
  if (parametercontainer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      parametercontainer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parametercontainer, submessage_arena);
    }
    
  } else {
    
  }
  parametercontainer_ = parametercontainer;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetParameterAsListPb.ParameterContainer)
}

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

// GetParameterValuePb

// .OpenTestSystem.OtxDiagManager.Common.DParameterPb Parameter = 1;
inline bool GetParameterValuePb::_internal_has_parameter() const {
  return this != internal_default_instance() && parameter_ != nullptr;
}
inline bool GetParameterValuePb::has_parameter() const {
  return _internal_has_parameter();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& GetParameterValuePb::_internal_parameter() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* p = parameter_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DParameterPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& GetParameterValuePb::parameter() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetParameterValuePb.Parameter)
  return _internal_parameter();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* GetParameterValuePb::release_parameter() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetParameterValuePb.Parameter)
  
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* temp = parameter_;
  parameter_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* GetParameterValuePb::_internal_mutable_parameter() {
  
  if (parameter_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DParameterPb>(GetArenaNoVirtual());
    parameter_ = p;
  }
  return parameter_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* GetParameterValuePb::mutable_parameter() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetParameterValuePb.Parameter)
  return _internal_mutable_parameter();
}
inline void GetParameterValuePb::set_allocated_parameter(::OpenTestSystem::OtxDiagManager::Common::DParameterPb* parameter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(parameter_);
  }
  if (parameter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parameter, submessage_arena);
    }
    
  } else {
    
  }
  parameter_ = parameter;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetParameterValuePb.Parameter)
}

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

// GetComplexComParameterPb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool GetComplexComParameterPb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool GetComplexComParameterPb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetComplexComParameterPb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetComplexComParameterPb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetComplexComParameterPb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetComplexComParameterPb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetComplexComParameterPb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void GetComplexComParameterPb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComChannel)
}

// string ComParameterName = 2;
inline void GetComplexComParameterPb::clear_comparametername() {
  comparametername_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetComplexComParameterPb::comparametername() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComParameterName)
  return _internal_comparametername();
}
inline void GetComplexComParameterPb::set_comparametername(const std::string& value) {
  _internal_set_comparametername(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComParameterName)
}
inline std::string* GetComplexComParameterPb::mutable_comparametername() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComParameterName)
  return _internal_mutable_comparametername();
}
inline const std::string& GetComplexComParameterPb::_internal_comparametername() const {
  return comparametername_.GetNoArena();
}
inline void GetComplexComParameterPb::_internal_set_comparametername(const std::string& value) {
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetComplexComParameterPb::set_comparametername(std::string&& value) {
  
  comparametername_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComParameterName)
}
inline void GetComplexComParameterPb::set_comparametername(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComParameterName)
}
inline void GetComplexComParameterPb::set_comparametername(const char* value, size_t size) {
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComParameterName)
}
inline std::string* GetComplexComParameterPb::_internal_mutable_comparametername() {
  
  return comparametername_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetComplexComParameterPb::release_comparametername() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComParameterName)
  
  return comparametername_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetComplexComParameterPb::set_allocated_comparametername(std::string* comparametername) {
  if (comparametername != nullptr) {
    
  } else {
    
  }
  comparametername_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), comparametername);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComplexComParameterPb.ComParameterName)
}

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

// GetComParameterValuePb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool GetComParameterValuePb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool GetComParameterValuePb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetComParameterValuePb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetComParameterValuePb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetComParameterValuePb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetComParameterValuePb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetComParameterValuePb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void GetComParameterValuePb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComChannel)
}

// string ComParameterName = 2;
inline void GetComParameterValuePb::clear_comparametername() {
  comparametername_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetComParameterValuePb::comparametername() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComParameterName)
  return _internal_comparametername();
}
inline void GetComParameterValuePb::set_comparametername(const std::string& value) {
  _internal_set_comparametername(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComParameterName)
}
inline std::string* GetComParameterValuePb::mutable_comparametername() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComParameterName)
  return _internal_mutable_comparametername();
}
inline const std::string& GetComParameterValuePb::_internal_comparametername() const {
  return comparametername_.GetNoArena();
}
inline void GetComParameterValuePb::_internal_set_comparametername(const std::string& value) {
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetComParameterValuePb::set_comparametername(std::string&& value) {
  
  comparametername_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComParameterName)
}
inline void GetComParameterValuePb::set_comparametername(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComParameterName)
}
inline void GetComParameterValuePb::set_comparametername(const char* value, size_t size) {
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComParameterName)
}
inline std::string* GetComParameterValuePb::_internal_mutable_comparametername() {
  
  return comparametername_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetComParameterValuePb::release_comparametername() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComParameterName)
  
  return comparametername_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetComParameterValuePb::set_allocated_comparametername(std::string* comparametername) {
  if (comparametername != nullptr) {
    
  } else {
    
  }
  comparametername_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), comparametername);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.ComParameterName)
}

// int32 DataType = 3;
inline void GetComParameterValuePb::clear_datatype() {
  datatype_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GetComParameterValuePb::_internal_datatype() const {
  return datatype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GetComParameterValuePb::datatype() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.DataType)
  return _internal_datatype();
}
inline void GetComParameterValuePb::_internal_set_datatype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  datatype_ = value;
}
inline void GetComParameterValuePb::set_datatype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_datatype(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetComParameterValuePb.DataType)
}

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

// GetDefaultComplexComParameterPb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool GetDefaultComplexComParameterPb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool GetDefaultComplexComParameterPb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetDefaultComplexComParameterPb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetDefaultComplexComParameterPb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetDefaultComplexComParameterPb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetDefaultComplexComParameterPb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetDefaultComplexComParameterPb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void GetDefaultComplexComParameterPb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComChannel)
}

// string ComParameterName = 2;
inline void GetDefaultComplexComParameterPb::clear_comparametername() {
  comparametername_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetDefaultComplexComParameterPb::comparametername() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComParameterName)
  return _internal_comparametername();
}
inline void GetDefaultComplexComParameterPb::set_comparametername(const std::string& value) {
  _internal_set_comparametername(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComParameterName)
}
inline std::string* GetDefaultComplexComParameterPb::mutable_comparametername() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComParameterName)
  return _internal_mutable_comparametername();
}
inline const std::string& GetDefaultComplexComParameterPb::_internal_comparametername() const {
  return comparametername_.GetNoArena();
}
inline void GetDefaultComplexComParameterPb::_internal_set_comparametername(const std::string& value) {
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetDefaultComplexComParameterPb::set_comparametername(std::string&& value) {
  
  comparametername_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComParameterName)
}
inline void GetDefaultComplexComParameterPb::set_comparametername(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComParameterName)
}
inline void GetDefaultComplexComParameterPb::set_comparametername(const char* value, size_t size) {
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComParameterName)
}
inline std::string* GetDefaultComplexComParameterPb::_internal_mutable_comparametername() {
  
  return comparametername_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetDefaultComplexComParameterPb::release_comparametername() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComParameterName)
  
  return comparametername_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetDefaultComplexComParameterPb::set_allocated_comparametername(std::string* comparametername) {
  if (comparametername != nullptr) {
    
  } else {
    
  }
  comparametername_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), comparametername);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetDefaultComplexComParameterPb.ComParameterName)
}

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

// GetDefaultComParameterValuePb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool GetDefaultComParameterValuePb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool GetDefaultComParameterValuePb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetDefaultComParameterValuePb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetDefaultComParameterValuePb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetDefaultComParameterValuePb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetDefaultComParameterValuePb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetDefaultComParameterValuePb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void GetDefaultComParameterValuePb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComChannel)
}

// string ComParameterName = 2;
inline void GetDefaultComParameterValuePb::clear_comparametername() {
  comparametername_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& GetDefaultComParameterValuePb::comparametername() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComParameterName)
  return _internal_comparametername();
}
inline void GetDefaultComParameterValuePb::set_comparametername(const std::string& value) {
  _internal_set_comparametername(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComParameterName)
}
inline std::string* GetDefaultComParameterValuePb::mutable_comparametername() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComParameterName)
  return _internal_mutable_comparametername();
}
inline const std::string& GetDefaultComParameterValuePb::_internal_comparametername() const {
  return comparametername_.GetNoArena();
}
inline void GetDefaultComParameterValuePb::_internal_set_comparametername(const std::string& value) {
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void GetDefaultComParameterValuePb::set_comparametername(std::string&& value) {
  
  comparametername_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComParameterName)
}
inline void GetDefaultComParameterValuePb::set_comparametername(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComParameterName)
}
inline void GetDefaultComParameterValuePb::set_comparametername(const char* value, size_t size) {
  
  comparametername_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComParameterName)
}
inline std::string* GetDefaultComParameterValuePb::_internal_mutable_comparametername() {
  
  return comparametername_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* GetDefaultComParameterValuePb::release_comparametername() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComParameterName)
  
  return comparametername_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void GetDefaultComParameterValuePb::set_allocated_comparametername(std::string* comparametername) {
  if (comparametername != nullptr) {
    
  } else {
    
  }
  comparametername_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), comparametername);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.ComParameterName)
}

// int32 DataType = 3;
inline void GetDefaultComParameterValuePb::clear_datatype() {
  datatype_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GetDefaultComParameterValuePb::_internal_datatype() const {
  return datatype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 GetDefaultComParameterValuePb::datatype() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.DataType)
  return _internal_datatype();
}
inline void GetDefaultComParameterValuePb::_internal_set_datatype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  datatype_ = value;
}
inline void GetDefaultComParameterValuePb::set_datatype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_datatype(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.GetDefaultComParameterValuePb.DataType)
}

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

// IdentifyAndSelectVariantPb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool IdentifyAndSelectVariantPb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool IdentifyAndSelectVariantPb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& IdentifyAndSelectVariantPb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& IdentifyAndSelectVariantPb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.IdentifyAndSelectVariantPb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* IdentifyAndSelectVariantPb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.IdentifyAndSelectVariantPb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* IdentifyAndSelectVariantPb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* IdentifyAndSelectVariantPb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.IdentifyAndSelectVariantPb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void IdentifyAndSelectVariantPb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.IdentifyAndSelectVariantPb.ComChannel)
}

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

// CloseComChannelPb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool CloseComChannelPb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool CloseComChannelPb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CloseComChannelPb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& CloseComChannelPb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.CloseComChannelPb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CloseComChannelPb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.CloseComChannelPb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CloseComChannelPb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* CloseComChannelPb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.CloseComChannelPb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void CloseComChannelPb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.CloseComChannelPb.ComChannel)
}

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

// SetComParameterPb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool SetComParameterPb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool SetComParameterPb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& SetComParameterPb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& SetComParameterPb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* SetComParameterPb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* SetComParameterPb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* SetComParameterPb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void SetComParameterPb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.ComChannel)
}

// string Name = 2;
inline void SetComParameterPb::clear_name() {
  name_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SetComParameterPb::name() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Name)
  return _internal_name();
}
inline void SetComParameterPb::set_name(const std::string& value) {
  _internal_set_name(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Name)
}
inline std::string* SetComParameterPb::mutable_name() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Name)
  return _internal_mutable_name();
}
inline const std::string& SetComParameterPb::_internal_name() const {
  return name_.GetNoArena();
}
inline void SetComParameterPb::_internal_set_name(const std::string& value) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void SetComParameterPb::set_name(std::string&& value) {
  
  name_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Name)
}
inline void SetComParameterPb::set_name(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Name)
}
inline void SetComParameterPb::set_name(const char* value, size_t size) {
  
  name_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Name)
}
inline std::string* SetComParameterPb::_internal_mutable_name() {
  
  return name_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SetComParameterPb::release_name() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Name)
  
  return name_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SetComParameterPb::set_allocated_name(std::string* name) {
  if (name != nullptr) {
    
  } else {
    
  }
  name_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Name)
}

// .OpenTestSystem.OtxDiagManager.Common.DValuePb Value = 3;
inline bool SetComParameterPb::_internal_has_value() const {
  return this != internal_default_instance() && value_ != nullptr;
}
inline bool SetComParameterPb::has_value() const {
  return _internal_has_value();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& SetComParameterPb::_internal_value() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DValuePb* p = value_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DValuePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DValuePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& SetComParameterPb::value() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Value)
  return _internal_value();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DValuePb* SetComParameterPb::release_value() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Value)
  
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* temp = value_;
  value_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DValuePb* SetComParameterPb::_internal_mutable_value() {
  
  if (value_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DValuePb>(GetArenaNoVirtual());
    value_ = p;
  }
  return value_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DValuePb* SetComParameterPb::mutable_value() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Value)
  return _internal_mutable_value();
}
inline void SetComParameterPb::set_allocated_value(::OpenTestSystem::OtxDiagManager::Common::DValuePb* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    
  } else {
    
  }
  value_ = value;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetComParameterPb.Value)
}

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

// SetComplexComParameterPb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool SetComplexComParameterPb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool SetComplexComParameterPb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& SetComplexComParameterPb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& SetComplexComParameterPb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetComplexComParameterPb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* SetComplexComParameterPb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetComplexComParameterPb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* SetComplexComParameterPb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* SetComplexComParameterPb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetComplexComParameterPb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void SetComplexComParameterPb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetComplexComParameterPb.ComChannel)
}

// .OpenTestSystem.OtxDiagManager.Common.DParameterPb Parameter = 2;
inline bool SetComplexComParameterPb::_internal_has_parameter() const {
  return this != internal_default_instance() && parameter_ != nullptr;
}
inline bool SetComplexComParameterPb::has_parameter() const {
  return _internal_has_parameter();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& SetComplexComParameterPb::_internal_parameter() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* p = parameter_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DParameterPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& SetComplexComParameterPb::parameter() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetComplexComParameterPb.Parameter)
  return _internal_parameter();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* SetComplexComParameterPb::release_parameter() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetComplexComParameterPb.Parameter)
  
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* temp = parameter_;
  parameter_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* SetComplexComParameterPb::_internal_mutable_parameter() {
  
  if (parameter_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DParameterPb>(GetArenaNoVirtual());
    parameter_ = p;
  }
  return parameter_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* SetComplexComParameterPb::mutable_parameter() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetComplexComParameterPb.Parameter)
  return _internal_mutable_parameter();
}
inline void SetComplexComParameterPb::set_allocated_parameter(::OpenTestSystem::OtxDiagManager::Common::DParameterPb* parameter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(parameter_);
  }
  if (parameter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parameter, submessage_arena);
    }
    
  } else {
    
  }
  parameter_ = parameter;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetComplexComParameterPb.Parameter)
}

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

// ExecuteDiagServicePb

// .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
inline bool ExecuteDiagServicePb::_internal_has_diagservice() const {
  return this != internal_default_instance() && diagservice_ != nullptr;
}
inline bool ExecuteDiagServicePb::has_diagservice() const {
  return _internal_has_diagservice();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& ExecuteDiagServicePb::_internal_diagservice() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* p = diagservice_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDiagServicePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& ExecuteDiagServicePb::diagservice() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.DiagService)
  return _internal_diagservice();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* ExecuteDiagServicePb::release_diagservice() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.DiagService)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* temp = diagservice_;
  diagservice_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* ExecuteDiagServicePb::_internal_mutable_diagservice() {
  
  if (diagservice_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb>(GetArenaNoVirtual());
    diagservice_ = p;
  }
  return diagservice_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* ExecuteDiagServicePb::mutable_diagservice() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.DiagService)
  return _internal_mutable_diagservice();
}
inline void ExecuteDiagServicePb::set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagservice_);
  }
  if (diagservice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      diagservice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, diagservice, submessage_arena);
    }
    
  } else {
    
  }
  diagservice_ = diagservice;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.DiagService)
}

// bool suppressPositiveResponse = 2;
inline void ExecuteDiagServicePb::clear_suppresspositiveresponse() {
  suppresspositiveresponse_ = false;
}
inline bool ExecuteDiagServicePb::_internal_suppresspositiveresponse() const {
  return suppresspositiveresponse_;
}
inline bool ExecuteDiagServicePb::suppresspositiveresponse() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.suppressPositiveResponse)
  return _internal_suppresspositiveresponse();
}
inline void ExecuteDiagServicePb::_internal_set_suppresspositiveresponse(bool value) {
  
  suppresspositiveresponse_ = value;
}
inline void ExecuteDiagServicePb::set_suppresspositiveresponse(bool value) {
  _internal_set_suppresspositiveresponse(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.suppressPositiveResponse)
}

// .OpenTestSystem.OtxDiagManager.Common.DParameterCollectionPb RequestParamters = 3;
inline bool ExecuteDiagServicePb::_internal_has_requestparamters() const {
  return this != internal_default_instance() && requestparamters_ != nullptr;
}
inline bool ExecuteDiagServicePb::has_requestparamters() const {
  return _internal_has_requestparamters();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb& ExecuteDiagServicePb::_internal_requestparamters() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* p = requestparamters_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DParameterCollectionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb& ExecuteDiagServicePb::requestparamters() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.RequestParamters)
  return _internal_requestparamters();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* ExecuteDiagServicePb::release_requestparamters() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.RequestParamters)
  
  ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* temp = requestparamters_;
  requestparamters_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* ExecuteDiagServicePb::_internal_mutable_requestparamters() {
  
  if (requestparamters_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb>(GetArenaNoVirtual());
    requestparamters_ = p;
  }
  return requestparamters_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* ExecuteDiagServicePb::mutable_requestparamters() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.RequestParamters)
  return _internal_mutable_requestparamters();
}
inline void ExecuteDiagServicePb::set_allocated_requestparamters(::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* requestparamters) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(requestparamters_);
  }
  if (requestparamters) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      requestparamters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, requestparamters, submessage_arena);
    }
    
  } else {
    
  }
  requestparamters_ = requestparamters;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.RequestParamters)
}

// .OpenTestSystem.OtxDiagManager.Common.DParameterCollectionPb ResponseParamters = 4;
inline bool ExecuteDiagServicePb::_internal_has_responseparamters() const {
  return this != internal_default_instance() && responseparamters_ != nullptr;
}
inline bool ExecuteDiagServicePb::has_responseparamters() const {
  return _internal_has_responseparamters();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb& ExecuteDiagServicePb::_internal_responseparamters() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* p = responseparamters_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DParameterCollectionPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb& ExecuteDiagServicePb::responseparamters() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.ResponseParamters)
  return _internal_responseparamters();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* ExecuteDiagServicePb::release_responseparamters() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.ResponseParamters)
  
  ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* temp = responseparamters_;
  responseparamters_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* ExecuteDiagServicePb::_internal_mutable_responseparamters() {
  
  if (responseparamters_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb>(GetArenaNoVirtual());
    responseparamters_ = p;
  }
  return responseparamters_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* ExecuteDiagServicePb::mutable_responseparamters() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.ResponseParamters)
  return _internal_mutable_responseparamters();
}
inline void ExecuteDiagServicePb::set_allocated_responseparamters(::OpenTestSystem::OtxDiagManager::Common::DParameterCollectionPb* responseparamters) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(responseparamters_);
  }
  if (responseparamters) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      responseparamters = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, responseparamters, submessage_arena);
    }
    
  } else {
    
  }
  responseparamters_ = responseparamters;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.ExecuteDiagServicePb.ResponseParamters)
}

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

// ExecuteHexDiagServicePb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool ExecuteHexDiagServicePb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool ExecuteHexDiagServicePb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& ExecuteHexDiagServicePb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& ExecuteHexDiagServicePb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* ExecuteHexDiagServicePb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* ExecuteHexDiagServicePb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* ExecuteHexDiagServicePb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void ExecuteHexDiagServicePb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.ComChannel)
}

// bytes HexRequest = 2;
inline void ExecuteHexDiagServicePb::clear_hexrequest() {
  hexrequest_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& ExecuteHexDiagServicePb::hexrequest() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.HexRequest)
  return _internal_hexrequest();
}
inline void ExecuteHexDiagServicePb::set_hexrequest(const std::string& value) {
  _internal_set_hexrequest(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.HexRequest)
}
inline std::string* ExecuteHexDiagServicePb::mutable_hexrequest() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.HexRequest)
  return _internal_mutable_hexrequest();
}
inline const std::string& ExecuteHexDiagServicePb::_internal_hexrequest() const {
  return hexrequest_.GetNoArena();
}
inline void ExecuteHexDiagServicePb::_internal_set_hexrequest(const std::string& value) {
  
  hexrequest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void ExecuteHexDiagServicePb::set_hexrequest(std::string&& value) {
  
  hexrequest_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.HexRequest)
}
inline void ExecuteHexDiagServicePb::set_hexrequest(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  hexrequest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.HexRequest)
}
inline void ExecuteHexDiagServicePb::set_hexrequest(const void* value, size_t size) {
  
  hexrequest_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.HexRequest)
}
inline std::string* ExecuteHexDiagServicePb::_internal_mutable_hexrequest() {
  
  return hexrequest_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* ExecuteHexDiagServicePb::release_hexrequest() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.HexRequest)
  
  return hexrequest_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void ExecuteHexDiagServicePb::set_allocated_hexrequest(std::string* hexrequest) {
  if (hexrequest != nullptr) {
    
  } else {
    
  }
  hexrequest_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), hexrequest);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.ExecuteHexDiagServicePb.HexRequest)
}

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

// StartRepeatedExecutionPb

// .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
inline bool StartRepeatedExecutionPb::_internal_has_diagservice() const {
  return this != internal_default_instance() && diagservice_ != nullptr;
}
inline bool StartRepeatedExecutionPb::has_diagservice() const {
  return _internal_has_diagservice();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& StartRepeatedExecutionPb::_internal_diagservice() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* p = diagservice_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDiagServicePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& StartRepeatedExecutionPb::diagservice() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.StartRepeatedExecutionPb.DiagService)
  return _internal_diagservice();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* StartRepeatedExecutionPb::release_diagservice() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.StartRepeatedExecutionPb.DiagService)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* temp = diagservice_;
  diagservice_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* StartRepeatedExecutionPb::_internal_mutable_diagservice() {
  
  if (diagservice_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb>(GetArenaNoVirtual());
    diagservice_ = p;
  }
  return diagservice_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* StartRepeatedExecutionPb::mutable_diagservice() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.StartRepeatedExecutionPb.DiagService)
  return _internal_mutable_diagservice();
}
inline void StartRepeatedExecutionPb::set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagservice_);
  }
  if (diagservice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      diagservice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, diagservice, submessage_arena);
    }
    
  } else {
    
  }
  diagservice_ = diagservice;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.StartRepeatedExecutionPb.DiagService)
}

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

// StopRepeatedExecutionPb

// .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
inline bool StopRepeatedExecutionPb::_internal_has_diagservice() const {
  return this != internal_default_instance() && diagservice_ != nullptr;
}
inline bool StopRepeatedExecutionPb::has_diagservice() const {
  return _internal_has_diagservice();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& StopRepeatedExecutionPb::_internal_diagservice() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* p = diagservice_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDiagServicePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& StopRepeatedExecutionPb::diagservice() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.StopRepeatedExecutionPb.DiagService)
  return _internal_diagservice();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* StopRepeatedExecutionPb::release_diagservice() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.StopRepeatedExecutionPb.DiagService)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* temp = diagservice_;
  diagservice_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* StopRepeatedExecutionPb::_internal_mutable_diagservice() {
  
  if (diagservice_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb>(GetArenaNoVirtual());
    diagservice_ = p;
  }
  return diagservice_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* StopRepeatedExecutionPb::mutable_diagservice() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.StopRepeatedExecutionPb.DiagService)
  return _internal_mutable_diagservice();
}
inline void StopRepeatedExecutionPb::set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagservice_);
  }
  if (diagservice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      diagservice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, diagservice, submessage_arena);
    }
    
  } else {
    
  }
  diagservice_ = diagservice;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.StopRepeatedExecutionPb.DiagService)
}

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

// SetRepetitionTimePb

// .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
inline bool SetRepetitionTimePb::_internal_has_diagservice() const {
  return this != internal_default_instance() && diagservice_ != nullptr;
}
inline bool SetRepetitionTimePb::has_diagservice() const {
  return _internal_has_diagservice();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& SetRepetitionTimePb::_internal_diagservice() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* p = diagservice_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDiagServicePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& SetRepetitionTimePb::diagservice() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetRepetitionTimePb.DiagService)
  return _internal_diagservice();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* SetRepetitionTimePb::release_diagservice() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetRepetitionTimePb.DiagService)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* temp = diagservice_;
  diagservice_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* SetRepetitionTimePb::_internal_mutable_diagservice() {
  
  if (diagservice_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb>(GetArenaNoVirtual());
    diagservice_ = p;
  }
  return diagservice_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* SetRepetitionTimePb::mutable_diagservice() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetRepetitionTimePb.DiagService)
  return _internal_mutable_diagservice();
}
inline void SetRepetitionTimePb::set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagservice_);
  }
  if (diagservice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      diagservice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, diagservice, submessage_arena);
    }
    
  } else {
    
  }
  diagservice_ = diagservice;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetRepetitionTimePb.DiagService)
}

// double RepetitionTime = 2;
inline void SetRepetitionTimePb::clear_repetitiontime() {
  repetitiontime_ = 0;
}
inline double SetRepetitionTimePb::_internal_repetitiontime() const {
  return repetitiontime_;
}
inline double SetRepetitionTimePb::repetitiontime() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetRepetitionTimePb.RepetitionTime)
  return _internal_repetitiontime();
}
inline void SetRepetitionTimePb::_internal_set_repetitiontime(double value) {
  
  repetitiontime_ = value;
}
inline void SetRepetitionTimePb::set_repetitiontime(double value) {
  _internal_set_repetitiontime(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.SetRepetitionTimePb.RepetitionTime)
}

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

// SetParameterValuePb

// .OpenTestSystem.OtxDiagManager.Common.DParameterPb Parameter = 1;
inline bool SetParameterValuePb::_internal_has_parameter() const {
  return this != internal_default_instance() && parameter_ != nullptr;
}
inline bool SetParameterValuePb::has_parameter() const {
  return _internal_has_parameter();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& SetParameterValuePb::_internal_parameter() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* p = parameter_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DParameterPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterPb& SetParameterValuePb::parameter() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetParameterValuePb.Parameter)
  return _internal_parameter();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* SetParameterValuePb::release_parameter() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetParameterValuePb.Parameter)
  
  ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* temp = parameter_;
  parameter_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* SetParameterValuePb::_internal_mutable_parameter() {
  
  if (parameter_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DParameterPb>(GetArenaNoVirtual());
    parameter_ = p;
  }
  return parameter_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterPb* SetParameterValuePb::mutable_parameter() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetParameterValuePb.Parameter)
  return _internal_mutable_parameter();
}
inline void SetParameterValuePb::set_allocated_parameter(::OpenTestSystem::OtxDiagManager::Common::DParameterPb* parameter) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(parameter_);
  }
  if (parameter) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      parameter = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parameter, submessage_arena);
    }
    
  } else {
    
  }
  parameter_ = parameter;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetParameterValuePb.Parameter)
}

// .OpenTestSystem.OtxDiagManager.Common.DValuePb Value = 2;
inline bool SetParameterValuePb::_internal_has_value() const {
  return this != internal_default_instance() && value_ != nullptr;
}
inline bool SetParameterValuePb::has_value() const {
  return _internal_has_value();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& SetParameterValuePb::_internal_value() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DValuePb* p = value_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DValuePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DValuePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& SetParameterValuePb::value() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetParameterValuePb.Value)
  return _internal_value();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DValuePb* SetParameterValuePb::release_value() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetParameterValuePb.Value)
  
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* temp = value_;
  value_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DValuePb* SetParameterValuePb::_internal_mutable_value() {
  
  if (value_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DValuePb>(GetArenaNoVirtual());
    value_ = p;
  }
  return value_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DValuePb* SetParameterValuePb::mutable_value() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetParameterValuePb.Value)
  return _internal_mutable_value();
}
inline void SetParameterValuePb::set_allocated_value(::OpenTestSystem::OtxDiagManager::Common::DValuePb* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    
  } else {
    
  }
  value_ = value;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetParameterValuePb.Value)
}

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

// SetParameterValueBySemanticPb

// .OpenTestSystem.OtxDiagManager.Common.DParameterContainerPb ParameterContainer = 1;
inline bool SetParameterValueBySemanticPb::_internal_has_parametercontainer() const {
  return this != internal_default_instance() && parametercontainer_ != nullptr;
}
inline bool SetParameterValueBySemanticPb::has_parametercontainer() const {
  return _internal_has_parametercontainer();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& SetParameterValueBySemanticPb::_internal_parametercontainer() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* p = parametercontainer_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DParameterContainerPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb& SetParameterValueBySemanticPb::parametercontainer() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.ParameterContainer)
  return _internal_parametercontainer();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* SetParameterValueBySemanticPb::release_parametercontainer() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.ParameterContainer)
  
  ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* temp = parametercontainer_;
  parametercontainer_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* SetParameterValueBySemanticPb::_internal_mutable_parametercontainer() {
  
  if (parametercontainer_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb>(GetArenaNoVirtual());
    parametercontainer_ = p;
  }
  return parametercontainer_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* SetParameterValueBySemanticPb::mutable_parametercontainer() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.ParameterContainer)
  return _internal_mutable_parametercontainer();
}
inline void SetParameterValueBySemanticPb::set_allocated_parametercontainer(::OpenTestSystem::OtxDiagManager::Common::DParameterContainerPb* parametercontainer) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(parametercontainer_);
  }
  if (parametercontainer) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      parametercontainer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, parametercontainer, submessage_arena);
    }
    
  } else {
    
  }
  parametercontainer_ = parametercontainer;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.ParameterContainer)
}

// string Semantic = 2;
inline void SetParameterValueBySemanticPb::clear_semantic() {
  semantic_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SetParameterValueBySemanticPb::semantic() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Semantic)
  return _internal_semantic();
}
inline void SetParameterValueBySemanticPb::set_semantic(const std::string& value) {
  _internal_set_semantic(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Semantic)
}
inline std::string* SetParameterValueBySemanticPb::mutable_semantic() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Semantic)
  return _internal_mutable_semantic();
}
inline const std::string& SetParameterValueBySemanticPb::_internal_semantic() const {
  return semantic_.GetNoArena();
}
inline void SetParameterValueBySemanticPb::_internal_set_semantic(const std::string& value) {
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void SetParameterValueBySemanticPb::set_semantic(std::string&& value) {
  
  semantic_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Semantic)
}
inline void SetParameterValueBySemanticPb::set_semantic(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Semantic)
}
inline void SetParameterValueBySemanticPb::set_semantic(const char* value, size_t size) {
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Semantic)
}
inline std::string* SetParameterValueBySemanticPb::_internal_mutable_semantic() {
  
  return semantic_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SetParameterValueBySemanticPb::release_semantic() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Semantic)
  
  return semantic_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SetParameterValueBySemanticPb::set_allocated_semantic(std::string* semantic) {
  if (semantic != nullptr) {
    
  } else {
    
  }
  semantic_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), semantic);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Semantic)
}

// .OpenTestSystem.OtxDiagManager.Common.DValuePb Value = 3;
inline bool SetParameterValueBySemanticPb::_internal_has_value() const {
  return this != internal_default_instance() && value_ != nullptr;
}
inline bool SetParameterValueBySemanticPb::has_value() const {
  return _internal_has_value();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& SetParameterValueBySemanticPb::_internal_value() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DValuePb* p = value_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DValuePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DValuePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DValuePb& SetParameterValueBySemanticPb::value() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Value)
  return _internal_value();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DValuePb* SetParameterValueBySemanticPb::release_value() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Value)
  
  ::OpenTestSystem::OtxDiagManager::Common::DValuePb* temp = value_;
  value_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DValuePb* SetParameterValueBySemanticPb::_internal_mutable_value() {
  
  if (value_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DValuePb>(GetArenaNoVirtual());
    value_ = p;
  }
  return value_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DValuePb* SetParameterValueBySemanticPb::mutable_value() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Value)
  return _internal_mutable_value();
}
inline void SetParameterValueBySemanticPb::set_allocated_value(::OpenTestSystem::OtxDiagManager::Common::DValuePb* value) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(value_);
  }
  if (value) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      value = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, value, submessage_arena);
    }
    
  } else {
    
  }
  value_ = value;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetParameterValueBySemanticPb.Value)
}

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

// SetPduPb

// .OpenTestSystem.OtxDiagManager.Common.DRequestPb Request = 1;
inline bool SetPduPb::_internal_has_request() const {
  return this != internal_default_instance() && request_ != nullptr;
}
inline bool SetPduPb::has_request() const {
  return _internal_has_request();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb& SetPduPb::_internal_request() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* p = request_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DRequestPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DRequestPb& SetPduPb::request() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Request)
  return _internal_request();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* SetPduPb::release_request() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Request)
  
  ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* temp = request_;
  request_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* SetPduPb::_internal_mutable_request() {
  
  if (request_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DRequestPb>(GetArenaNoVirtual());
    request_ = p;
  }
  return request_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DRequestPb* SetPduPb::mutable_request() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Request)
  return _internal_mutable_request();
}
inline void SetPduPb::set_allocated_request(::OpenTestSystem::OtxDiagManager::Common::DRequestPb* request) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_);
  }
  if (request) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, request, submessage_arena);
    }
    
  } else {
    
  }
  request_ = request;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Request)
}

// bytes Pdu = 2;
inline void SetPduPb::clear_pdu() {
  pdu_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& SetPduPb::pdu() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Pdu)
  return _internal_pdu();
}
inline void SetPduPb::set_pdu(const std::string& value) {
  _internal_set_pdu(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Pdu)
}
inline std::string* SetPduPb::mutable_pdu() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Pdu)
  return _internal_mutable_pdu();
}
inline const std::string& SetPduPb::_internal_pdu() const {
  return pdu_.GetNoArena();
}
inline void SetPduPb::_internal_set_pdu(const std::string& value) {
  
  pdu_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void SetPduPb::set_pdu(std::string&& value) {
  
  pdu_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Pdu)
}
inline void SetPduPb::set_pdu(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  pdu_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Pdu)
}
inline void SetPduPb::set_pdu(const void* value, size_t size) {
  
  pdu_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Pdu)
}
inline std::string* SetPduPb::_internal_mutable_pdu() {
  
  return pdu_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* SetPduPb::release_pdu() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Pdu)
  
  return pdu_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void SetPduPb::set_allocated_pdu(std::string* pdu) {
  if (pdu != nullptr) {
    
  } else {
    
  }
  pdu_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), pdu);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.SetPduPb.Pdu)
}

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

// GetComChannelEcuVariantNamePb

// .OpenTestSystem.OtxDiagManager.Common.DComChannelPb ComChannel = 1;
inline bool GetComChannelEcuVariantNamePb::_internal_has_comchannel() const {
  return this != internal_default_instance() && comchannel_ != nullptr;
}
inline bool GetComChannelEcuVariantNamePb::has_comchannel() const {
  return _internal_has_comchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetComChannelEcuVariantNamePb::_internal_comchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* p = comchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb& GetComChannelEcuVariantNamePb::comchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.GetComChannelEcuVariantNamePb.ComChannel)
  return _internal_comchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetComChannelEcuVariantNamePb::release_comchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.GetComChannelEcuVariantNamePb.ComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* temp = comchannel_;
  comchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetComChannelEcuVariantNamePb::_internal_mutable_comchannel() {
  
  if (comchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DComChannelPb>(GetArenaNoVirtual());
    comchannel_ = p;
  }
  return comchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* GetComChannelEcuVariantNamePb::mutable_comchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.GetComChannelEcuVariantNamePb.ComChannel)
  return _internal_mutable_comchannel();
}
inline void GetComChannelEcuVariantNamePb::set_allocated_comchannel(::OpenTestSystem::OtxDiagManager::Common::DComChannelPb* comchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(comchannel_);
  }
  if (comchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      comchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, comchannel, submessage_arena);
    }
    
  } else {
    
  }
  comchannel_ = comchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.GetComChannelEcuVariantNamePb.ComChannel)
}

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

// OnPrimitiveTerminatedPb

// .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
inline bool OnPrimitiveTerminatedPb::_internal_has_diagservice() const {
  return this != internal_default_instance() && diagservice_ != nullptr;
}
inline bool OnPrimitiveTerminatedPb::has_diagservice() const {
  return _internal_has_diagservice();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& OnPrimitiveTerminatedPb::_internal_diagservice() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* p = diagservice_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDiagServicePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& OnPrimitiveTerminatedPb::diagservice() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveTerminatedPb.DiagService)
  return _internal_diagservice();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* OnPrimitiveTerminatedPb::release_diagservice() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveTerminatedPb.DiagService)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* temp = diagservice_;
  diagservice_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* OnPrimitiveTerminatedPb::_internal_mutable_diagservice() {
  
  if (diagservice_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb>(GetArenaNoVirtual());
    diagservice_ = p;
  }
  return diagservice_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* OnPrimitiveTerminatedPb::mutable_diagservice() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveTerminatedPb.DiagService)
  return _internal_mutable_diagservice();
}
inline void OnPrimitiveTerminatedPb::set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagservice_);
  }
  if (diagservice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      diagservice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, diagservice, submessage_arena);
    }
    
  } else {
    
  }
  diagservice_ = diagservice;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveTerminatedPb.DiagService)
}

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

// OnPrimitiveHasResultPb

// .OpenTestSystem.OtxDiagManager.Common.DDiagServicePb DiagService = 1;
inline bool OnPrimitiveHasResultPb::_internal_has_diagservice() const {
  return this != internal_default_instance() && diagservice_ != nullptr;
}
inline bool OnPrimitiveHasResultPb::has_diagservice() const {
  return _internal_has_diagservice();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& OnPrimitiveHasResultPb::_internal_diagservice() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* p = diagservice_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDiagServicePb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb& OnPrimitiveHasResultPb::diagservice() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveHasResultPb.DiagService)
  return _internal_diagservice();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* OnPrimitiveHasResultPb::release_diagservice() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveHasResultPb.DiagService)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* temp = diagservice_;
  diagservice_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* OnPrimitiveHasResultPb::_internal_mutable_diagservice() {
  
  if (diagservice_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb>(GetArenaNoVirtual());
    diagservice_ = p;
  }
  return diagservice_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* OnPrimitiveHasResultPb::mutable_diagservice() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveHasResultPb.DiagService)
  return _internal_mutable_diagservice();
}
inline void OnPrimitiveHasResultPb::set_allocated_diagservice(::OpenTestSystem::OtxDiagManager::Common::DDiagServicePb* diagservice) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(diagservice_);
  }
  if (diagservice) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      diagservice = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, diagservice, submessage_arena);
    }
    
  } else {
    
  }
  diagservice_ = diagservice;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveHasResultPb.DiagService)
}

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

// OnPrimitiveBufferHasResultPb

// .OpenTestSystem.OtxDiagManager.Common.DResultPb Result = 1;
inline bool OnPrimitiveBufferHasResultPb::_internal_has_result() const {
  return this != internal_default_instance() && result_ != nullptr;
}
inline bool OnPrimitiveBufferHasResultPb::has_result() const {
  return _internal_has_result();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DResultPb& OnPrimitiveBufferHasResultPb::_internal_result() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DResultPb* p = result_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DResultPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DResultPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DResultPb& OnPrimitiveBufferHasResultPb::result() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveBufferHasResultPb.Result)
  return _internal_result();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DResultPb* OnPrimitiveBufferHasResultPb::release_result() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveBufferHasResultPb.Result)
  
  ::OpenTestSystem::OtxDiagManager::Common::DResultPb* temp = result_;
  result_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DResultPb* OnPrimitiveBufferHasResultPb::_internal_mutable_result() {
  
  if (result_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DResultPb>(GetArenaNoVirtual());
    result_ = p;
  }
  return result_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DResultPb* OnPrimitiveBufferHasResultPb::mutable_result() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveBufferHasResultPb.Result)
  return _internal_mutable_result();
}
inline void OnPrimitiveBufferHasResultPb::set_allocated_result(::OpenTestSystem::OtxDiagManager::Common::DResultPb* result) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(result_);
  }
  if (result) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      result = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, result, submessage_arena);
    }
    
  } else {
    
  }
  result_ = result;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.OnPrimitiveBufferHasResultPb.Result)
}

#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_DiagComCommandsPb_2eproto
