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

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

// Internal implementation detail -- do not use these members.
struct TableStruct_EcuConfigurationDataModelsPb_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[5]
    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_EcuConfigurationDataModelsPb_2eproto;
namespace OpenTestSystem {
namespace OtxDiagManager {
namespace Common {
class DDbConfigurationDataPb;
class DDbConfigurationDataPbDefaultTypeInternal;
extern DDbConfigurationDataPbDefaultTypeInternal _DDbConfigurationDataPb_default_instance_;
class DDbConfigurationRecordPb;
class DDbConfigurationRecordPbDefaultTypeInternal;
extern DDbConfigurationRecordPbDefaultTypeInternal _DDbConfigurationRecordPb_default_instance_;
class DDbDataRecordPb;
class DDbDataRecordPbDefaultTypeInternal;
extern DDbDataRecordPbDefaultTypeInternal _DDbDataRecordPb_default_instance_;
class DDbItemValuePb;
class DDbItemValuePbDefaultTypeInternal;
extern DDbItemValuePbDefaultTypeInternal _DDbItemValuePb_default_instance_;
class DDbOptionItemPb;
class DDbOptionItemPbDefaultTypeInternal;
extern DDbOptionItemPbDefaultTypeInternal _DDbOptionItemPb_default_instance_;
}  // namespace Common
}  // namespace OtxDiagManager
}  // namespace OpenTestSystem
PROTOBUF_NAMESPACE_OPEN
template<> ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::DDbDataRecordPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDbDataRecordPb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb>(Arena*);
template<> ::OpenTestSystem::OtxDiagManager::Common::DDbOptionItemPb* Arena::CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDbOptionItemPb>(Arena*);
PROTOBUF_NAMESPACE_CLOSE
namespace OpenTestSystem {
namespace OtxDiagManager {
namespace Common {

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

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kDescriptionFieldNumber = 2,
    kDescriptionIDFieldNumber = 3,
    kLongNameFieldNumber = 4,
    kLongNameIDFieldNumber = 5,
    kShortNameFieldNumber = 6,
    kUniqueObjectIdentifierFieldNumber = 7,
    kDbComChannelFieldNumber = 1,
    kObjectTypeFieldNumber = 8,
  };
  // string Description = 2;
  void clear_description();
  const std::string& description() const;
  void set_description(const std::string& value);
  void set_description(std::string&& value);
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  std::string* mutable_description();
  std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // string DescriptionID = 3;
  void clear_descriptionid();
  const std::string& descriptionid() const;
  void set_descriptionid(const std::string& value);
  void set_descriptionid(std::string&& value);
  void set_descriptionid(const char* value);
  void set_descriptionid(const char* value, size_t size);
  std::string* mutable_descriptionid();
  std::string* release_descriptionid();
  void set_allocated_descriptionid(std::string* descriptionid);
  private:
  const std::string& _internal_descriptionid() const;
  void _internal_set_descriptionid(const std::string& value);
  std::string* _internal_mutable_descriptionid();
  public:

  // string LongName = 4;
  void clear_longname();
  const std::string& longname() const;
  void set_longname(const std::string& value);
  void set_longname(std::string&& value);
  void set_longname(const char* value);
  void set_longname(const char* value, size_t size);
  std::string* mutable_longname();
  std::string* release_longname();
  void set_allocated_longname(std::string* longname);
  private:
  const std::string& _internal_longname() const;
  void _internal_set_longname(const std::string& value);
  std::string* _internal_mutable_longname();
  public:

  // string LongNameID = 5;
  void clear_longnameid();
  const std::string& longnameid() const;
  void set_longnameid(const std::string& value);
  void set_longnameid(std::string&& value);
  void set_longnameid(const char* value);
  void set_longnameid(const char* value, size_t size);
  std::string* mutable_longnameid();
  std::string* release_longnameid();
  void set_allocated_longnameid(std::string* longnameid);
  private:
  const std::string& _internal_longnameid() const;
  void _internal_set_longnameid(const std::string& value);
  std::string* _internal_mutable_longnameid();
  public:

  // string ShortName = 6;
  void clear_shortname();
  const std::string& shortname() const;
  void set_shortname(const std::string& value);
  void set_shortname(std::string&& value);
  void set_shortname(const char* value);
  void set_shortname(const char* value, size_t size);
  std::string* mutable_shortname();
  std::string* release_shortname();
  void set_allocated_shortname(std::string* shortname);
  private:
  const std::string& _internal_shortname() const;
  void _internal_set_shortname(const std::string& value);
  std::string* _internal_mutable_shortname();
  public:

  // string UniqueObjectIdentifier = 7;
  void clear_uniqueobjectidentifier();
  const std::string& uniqueobjectidentifier() const;
  void set_uniqueobjectidentifier(const std::string& value);
  void set_uniqueobjectidentifier(std::string&& value);
  void set_uniqueobjectidentifier(const char* value);
  void set_uniqueobjectidentifier(const char* value, size_t size);
  std::string* mutable_uniqueobjectidentifier();
  std::string* release_uniqueobjectidentifier();
  void set_allocated_uniqueobjectidentifier(std::string* uniqueobjectidentifier);
  private:
  const std::string& _internal_uniqueobjectidentifier() const;
  void _internal_set_uniqueobjectidentifier(const std::string& value);
  std::string* _internal_mutable_uniqueobjectidentifier();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DDbComChannelPb DbComChannel = 1;
  bool has_dbcomchannel() const;
  private:
  bool _internal_has_dbcomchannel() const;
  public:
  void clear_dbcomchannel();
  const ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb& dbcomchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb* release_dbcomchannel();
  ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb* mutable_dbcomchannel();
  void set_allocated_dbcomchannel(::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb* dbcomchannel);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb& _internal_dbcomchannel() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb* _internal_mutable_dbcomchannel();
  public:

  // int32 ObjectType = 8;
  void clear_objecttype();
  ::PROTOBUF_NAMESPACE_ID::int32 objecttype() const;
  void set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_objecttype() const;
  void _internal_set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr descriptionid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr longname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr longnameid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shortname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uniqueobjectidentifier_;
  ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb* dbcomchannel_;
  ::PROTOBUF_NAMESPACE_ID::int32 objecttype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_EcuConfigurationDataModelsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kDescriptionFieldNumber = 2,
    kDescriptionIDFieldNumber = 3,
    kLongNameFieldNumber = 4,
    kLongNameIDFieldNumber = 5,
    kShortNameFieldNumber = 6,
    kUniqueObjectIdentifierFieldNumber = 7,
    kDbConfigurationDataFieldNumber = 1,
    kObjectTypeFieldNumber = 8,
  };
  // string Description = 2;
  void clear_description();
  const std::string& description() const;
  void set_description(const std::string& value);
  void set_description(std::string&& value);
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  std::string* mutable_description();
  std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // string DescriptionID = 3;
  void clear_descriptionid();
  const std::string& descriptionid() const;
  void set_descriptionid(const std::string& value);
  void set_descriptionid(std::string&& value);
  void set_descriptionid(const char* value);
  void set_descriptionid(const char* value, size_t size);
  std::string* mutable_descriptionid();
  std::string* release_descriptionid();
  void set_allocated_descriptionid(std::string* descriptionid);
  private:
  const std::string& _internal_descriptionid() const;
  void _internal_set_descriptionid(const std::string& value);
  std::string* _internal_mutable_descriptionid();
  public:

  // string LongName = 4;
  void clear_longname();
  const std::string& longname() const;
  void set_longname(const std::string& value);
  void set_longname(std::string&& value);
  void set_longname(const char* value);
  void set_longname(const char* value, size_t size);
  std::string* mutable_longname();
  std::string* release_longname();
  void set_allocated_longname(std::string* longname);
  private:
  const std::string& _internal_longname() const;
  void _internal_set_longname(const std::string& value);
  std::string* _internal_mutable_longname();
  public:

  // string LongNameID = 5;
  void clear_longnameid();
  const std::string& longnameid() const;
  void set_longnameid(const std::string& value);
  void set_longnameid(std::string&& value);
  void set_longnameid(const char* value);
  void set_longnameid(const char* value, size_t size);
  std::string* mutable_longnameid();
  std::string* release_longnameid();
  void set_allocated_longnameid(std::string* longnameid);
  private:
  const std::string& _internal_longnameid() const;
  void _internal_set_longnameid(const std::string& value);
  std::string* _internal_mutable_longnameid();
  public:

  // string ShortName = 6;
  void clear_shortname();
  const std::string& shortname() const;
  void set_shortname(const std::string& value);
  void set_shortname(std::string&& value);
  void set_shortname(const char* value);
  void set_shortname(const char* value, size_t size);
  std::string* mutable_shortname();
  std::string* release_shortname();
  void set_allocated_shortname(std::string* shortname);
  private:
  const std::string& _internal_shortname() const;
  void _internal_set_shortname(const std::string& value);
  std::string* _internal_mutable_shortname();
  public:

  // string UniqueObjectIdentifier = 7;
  void clear_uniqueobjectidentifier();
  const std::string& uniqueobjectidentifier() const;
  void set_uniqueobjectidentifier(const std::string& value);
  void set_uniqueobjectidentifier(std::string&& value);
  void set_uniqueobjectidentifier(const char* value);
  void set_uniqueobjectidentifier(const char* value, size_t size);
  std::string* mutable_uniqueobjectidentifier();
  std::string* release_uniqueobjectidentifier();
  void set_allocated_uniqueobjectidentifier(std::string* uniqueobjectidentifier);
  private:
  const std::string& _internal_uniqueobjectidentifier() const;
  void _internal_set_uniqueobjectidentifier(const std::string& value);
  std::string* _internal_mutable_uniqueobjectidentifier();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb DbConfigurationData = 1;
  bool has_dbconfigurationdata() const;
  private:
  bool _internal_has_dbconfigurationdata() const;
  public:
  void clear_dbconfigurationdata();
  const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb& dbconfigurationdata() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* release_dbconfigurationdata();
  ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* mutable_dbconfigurationdata();
  void set_allocated_dbconfigurationdata(::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* dbconfigurationdata);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb& _internal_dbconfigurationdata() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* _internal_mutable_dbconfigurationdata();
  public:

  // int32 ObjectType = 8;
  void clear_objecttype();
  ::PROTOBUF_NAMESPACE_ID::int32 objecttype() const;
  void set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_objecttype() const;
  void _internal_set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr descriptionid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr longname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr longnameid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shortname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uniqueobjectidentifier_;
  ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* dbconfigurationdata_;
  ::PROTOBUF_NAMESPACE_ID::int32 objecttype_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_EcuConfigurationDataModelsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

  enum KindCase {
    kDataId = 9,
    kKey = 10,
    KIND_NOT_SET = 0,
  };

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

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

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

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

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

  public:

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

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

  enum : int {
    kDescriptionFieldNumber = 2,
    kDescriptionIDFieldNumber = 3,
    kLongNameFieldNumber = 4,
    kLongNameIDFieldNumber = 5,
    kShortNameFieldNumber = 6,
    kUniqueObjectIdentifierFieldNumber = 7,
    kDbConfigurationRecordFieldNumber = 1,
    kObjectTypeFieldNumber = 8,
    kDataIdFieldNumber = 9,
    kKeyFieldNumber = 10,
  };
  // string Description = 2;
  void clear_description();
  const std::string& description() const;
  void set_description(const std::string& value);
  void set_description(std::string&& value);
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  std::string* mutable_description();
  std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // string DescriptionID = 3;
  void clear_descriptionid();
  const std::string& descriptionid() const;
  void set_descriptionid(const std::string& value);
  void set_descriptionid(std::string&& value);
  void set_descriptionid(const char* value);
  void set_descriptionid(const char* value, size_t size);
  std::string* mutable_descriptionid();
  std::string* release_descriptionid();
  void set_allocated_descriptionid(std::string* descriptionid);
  private:
  const std::string& _internal_descriptionid() const;
  void _internal_set_descriptionid(const std::string& value);
  std::string* _internal_mutable_descriptionid();
  public:

  // string LongName = 4;
  void clear_longname();
  const std::string& longname() const;
  void set_longname(const std::string& value);
  void set_longname(std::string&& value);
  void set_longname(const char* value);
  void set_longname(const char* value, size_t size);
  std::string* mutable_longname();
  std::string* release_longname();
  void set_allocated_longname(std::string* longname);
  private:
  const std::string& _internal_longname() const;
  void _internal_set_longname(const std::string& value);
  std::string* _internal_mutable_longname();
  public:

  // string LongNameID = 5;
  void clear_longnameid();
  const std::string& longnameid() const;
  void set_longnameid(const std::string& value);
  void set_longnameid(std::string&& value);
  void set_longnameid(const char* value);
  void set_longnameid(const char* value, size_t size);
  std::string* mutable_longnameid();
  std::string* release_longnameid();
  void set_allocated_longnameid(std::string* longnameid);
  private:
  const std::string& _internal_longnameid() const;
  void _internal_set_longnameid(const std::string& value);
  std::string* _internal_mutable_longnameid();
  public:

  // string ShortName = 6;
  void clear_shortname();
  const std::string& shortname() const;
  void set_shortname(const std::string& value);
  void set_shortname(std::string&& value);
  void set_shortname(const char* value);
  void set_shortname(const char* value, size_t size);
  std::string* mutable_shortname();
  std::string* release_shortname();
  void set_allocated_shortname(std::string* shortname);
  private:
  const std::string& _internal_shortname() const;
  void _internal_set_shortname(const std::string& value);
  std::string* _internal_mutable_shortname();
  public:

  // string UniqueObjectIdentifier = 7;
  void clear_uniqueobjectidentifier();
  const std::string& uniqueobjectidentifier() const;
  void set_uniqueobjectidentifier(const std::string& value);
  void set_uniqueobjectidentifier(std::string&& value);
  void set_uniqueobjectidentifier(const char* value);
  void set_uniqueobjectidentifier(const char* value, size_t size);
  std::string* mutable_uniqueobjectidentifier();
  std::string* release_uniqueobjectidentifier();
  void set_allocated_uniqueobjectidentifier(std::string* uniqueobjectidentifier);
  private:
  const std::string& _internal_uniqueobjectidentifier() const;
  void _internal_set_uniqueobjectidentifier(const std::string& value);
  std::string* _internal_mutable_uniqueobjectidentifier();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb DbConfigurationRecord = 1;
  bool has_dbconfigurationrecord() const;
  private:
  bool _internal_has_dbconfigurationrecord() const;
  public:
  void clear_dbconfigurationrecord();
  const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb& dbconfigurationrecord() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* release_dbconfigurationrecord();
  ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* mutable_dbconfigurationrecord();
  void set_allocated_dbconfigurationrecord(::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* dbconfigurationrecord);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb& _internal_dbconfigurationrecord() const;
  ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* _internal_mutable_dbconfigurationrecord();
  public:

  // int32 ObjectType = 8;
  void clear_objecttype();
  ::PROTOBUF_NAMESPACE_ID::int32 objecttype() const;
  void set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_objecttype() const;
  void _internal_set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // string DataId = 9;
  private:
  bool _internal_has_dataid() const;
  public:
  void clear_dataid();
  const std::string& dataid() const;
  void set_dataid(const std::string& value);
  void set_dataid(std::string&& value);
  void set_dataid(const char* value);
  void set_dataid(const char* value, size_t size);
  std::string* mutable_dataid();
  std::string* release_dataid();
  void set_allocated_dataid(std::string* dataid);
  private:
  const std::string& _internal_dataid() const;
  void _internal_set_dataid(const std::string& value);
  std::string* _internal_mutable_dataid();
  public:

  // string Key = 10;
  private:
  bool _internal_has_key() const;
  public:
  void clear_key();
  const std::string& key() const;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

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

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr descriptionid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr longname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr longnameid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shortname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uniqueobjectidentifier_;
  ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* dbconfigurationrecord_;
  ::PROTOBUF_NAMESPACE_ID::int32 objecttype_;
  union KindUnion {
    KindUnion() {}
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr dataid_;
    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  } kind_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];

  friend struct ::TableStruct_EcuConfigurationDataModelsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kKeyFieldNumber = 1,
    kMeaningFieldNumber = 2,
    kMeaningIdFieldNumber = 3,
    kPhysicalConstantValueAsStringFieldNumber = 4,
    kRuleFieldNumber = 5,
  };
  // string Key = 1;
  void clear_key();
  const std::string& key() const;
  void set_key(const std::string& value);
  void set_key(std::string&& value);
  void set_key(const char* value);
  void set_key(const char* value, size_t size);
  std::string* mutable_key();
  std::string* release_key();
  void set_allocated_key(std::string* key);
  private:
  const std::string& _internal_key() const;
  void _internal_set_key(const std::string& value);
  std::string* _internal_mutable_key();
  public:

  // string Meaning = 2;
  void clear_meaning();
  const std::string& meaning() const;
  void set_meaning(const std::string& value);
  void set_meaning(std::string&& value);
  void set_meaning(const char* value);
  void set_meaning(const char* value, size_t size);
  std::string* mutable_meaning();
  std::string* release_meaning();
  void set_allocated_meaning(std::string* meaning);
  private:
  const std::string& _internal_meaning() const;
  void _internal_set_meaning(const std::string& value);
  std::string* _internal_mutable_meaning();
  public:

  // string MeaningId = 3;
  void clear_meaningid();
  const std::string& meaningid() const;
  void set_meaningid(const std::string& value);
  void set_meaningid(std::string&& value);
  void set_meaningid(const char* value);
  void set_meaningid(const char* value, size_t size);
  std::string* mutable_meaningid();
  std::string* release_meaningid();
  void set_allocated_meaningid(std::string* meaningid);
  private:
  const std::string& _internal_meaningid() const;
  void _internal_set_meaningid(const std::string& value);
  std::string* _internal_mutable_meaningid();
  public:

  // string PhysicalConstantValueAsString = 4;
  void clear_physicalconstantvalueasstring();
  const std::string& physicalconstantvalueasstring() const;
  void set_physicalconstantvalueasstring(const std::string& value);
  void set_physicalconstantvalueasstring(std::string&& value);
  void set_physicalconstantvalueasstring(const char* value);
  void set_physicalconstantvalueasstring(const char* value, size_t size);
  std::string* mutable_physicalconstantvalueasstring();
  std::string* release_physicalconstantvalueasstring();
  void set_allocated_physicalconstantvalueasstring(std::string* physicalconstantvalueasstring);
  private:
  const std::string& _internal_physicalconstantvalueasstring() const;
  void _internal_set_physicalconstantvalueasstring(const std::string& value);
  std::string* _internal_mutable_physicalconstantvalueasstring();
  public:

  // string Rule = 5;
  void clear_rule();
  const std::string& rule() const;
  void set_rule(const std::string& value);
  void set_rule(std::string&& value);
  void set_rule(const char* value);
  void set_rule(const char* value, size_t size);
  std::string* mutable_rule();
  std::string* release_rule();
  void set_allocated_rule(std::string* rule);
  private:
  const std::string& _internal_rule() const;
  void _internal_set_rule(const std::string& value);
  std::string* _internal_mutable_rule();
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr meaning_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr meaningid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr physicalconstantvalueasstring_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rule_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_EcuConfigurationDataModelsPb_2eproto;
};
// -------------------------------------------------------------------

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

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

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

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

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

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

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

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

  public:

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

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

  enum : int {
    kDbItemValuesFieldNumber = 18,
    kTextTableElementsFieldNumber = 19,
    kDescriptionFieldNumber = 1,
    kDescriptionIDFieldNumber = 2,
    kLongNameFieldNumber = 3,
    kLongNameIDFieldNumber = 4,
    kShortNameFieldNumber = 5,
    kUniqueObjectIdentifierFieldNumber = 6,
    kSemanticFieldNumber = 13,
    kUnitAsStringFieldNumber = 14,
    kPhysicalDefaultValueAsStringFieldNumber = 15,
    kReadAudienceStateFieldNumber = 16,
    kWriteAudienceStateFieldNumber = 17,
    kIntervalFieldNumber = 11,
    kObjectTypeFieldNumber = 7,
    kBitLengthFieldNumber = 8,
    kBitPositionFieldNumber = 9,
    kDecimalPlacesFieldNumber = 10,
    kDataTypeFieldNumber = 12,
    kIsComplexFieldNumber = 20,
    kBytePositionFieldNumber = 21,
  };
  // repeated .OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb DbItemValues = 18;
  int dbitemvalues_size() const;
  private:
  int _internal_dbitemvalues_size() const;
  public:
  void clear_dbitemvalues();
  ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb* mutable_dbitemvalues(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb >*
      mutable_dbitemvalues();
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb& _internal_dbitemvalues(int index) const;
  ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb* _internal_add_dbitemvalues();
  public:
  const ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb& dbitemvalues(int index) const;
  ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb* add_dbitemvalues();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb >&
      dbitemvalues() const;

  // repeated .OpenTestSystem.OtxDiagManager.Common.DTextTableElementPb TextTableElements = 19;
  int texttableelements_size() const;
  private:
  int _internal_texttableelements_size() const;
  public:
  void clear_texttableelements();
  ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb* mutable_texttableelements(int index);
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb >*
      mutable_texttableelements();
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb& _internal_texttableelements(int index) const;
  ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb* _internal_add_texttableelements();
  public:
  const ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb& texttableelements(int index) const;
  ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb* add_texttableelements();
  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb >&
      texttableelements() const;

  // string Description = 1;
  void clear_description();
  const std::string& description() const;
  void set_description(const std::string& value);
  void set_description(std::string&& value);
  void set_description(const char* value);
  void set_description(const char* value, size_t size);
  std::string* mutable_description();
  std::string* release_description();
  void set_allocated_description(std::string* description);
  private:
  const std::string& _internal_description() const;
  void _internal_set_description(const std::string& value);
  std::string* _internal_mutable_description();
  public:

  // string DescriptionID = 2;
  void clear_descriptionid();
  const std::string& descriptionid() const;
  void set_descriptionid(const std::string& value);
  void set_descriptionid(std::string&& value);
  void set_descriptionid(const char* value);
  void set_descriptionid(const char* value, size_t size);
  std::string* mutable_descriptionid();
  std::string* release_descriptionid();
  void set_allocated_descriptionid(std::string* descriptionid);
  private:
  const std::string& _internal_descriptionid() const;
  void _internal_set_descriptionid(const std::string& value);
  std::string* _internal_mutable_descriptionid();
  public:

  // string LongName = 3;
  void clear_longname();
  const std::string& longname() const;
  void set_longname(const std::string& value);
  void set_longname(std::string&& value);
  void set_longname(const char* value);
  void set_longname(const char* value, size_t size);
  std::string* mutable_longname();
  std::string* release_longname();
  void set_allocated_longname(std::string* longname);
  private:
  const std::string& _internal_longname() const;
  void _internal_set_longname(const std::string& value);
  std::string* _internal_mutable_longname();
  public:

  // string LongNameID = 4;
  void clear_longnameid();
  const std::string& longnameid() const;
  void set_longnameid(const std::string& value);
  void set_longnameid(std::string&& value);
  void set_longnameid(const char* value);
  void set_longnameid(const char* value, size_t size);
  std::string* mutable_longnameid();
  std::string* release_longnameid();
  void set_allocated_longnameid(std::string* longnameid);
  private:
  const std::string& _internal_longnameid() const;
  void _internal_set_longnameid(const std::string& value);
  std::string* _internal_mutable_longnameid();
  public:

  // string ShortName = 5;
  void clear_shortname();
  const std::string& shortname() const;
  void set_shortname(const std::string& value);
  void set_shortname(std::string&& value);
  void set_shortname(const char* value);
  void set_shortname(const char* value, size_t size);
  std::string* mutable_shortname();
  std::string* release_shortname();
  void set_allocated_shortname(std::string* shortname);
  private:
  const std::string& _internal_shortname() const;
  void _internal_set_shortname(const std::string& value);
  std::string* _internal_mutable_shortname();
  public:

  // string UniqueObjectIdentifier = 6;
  void clear_uniqueobjectidentifier();
  const std::string& uniqueobjectidentifier() const;
  void set_uniqueobjectidentifier(const std::string& value);
  void set_uniqueobjectidentifier(std::string&& value);
  void set_uniqueobjectidentifier(const char* value);
  void set_uniqueobjectidentifier(const char* value, size_t size);
  std::string* mutable_uniqueobjectidentifier();
  std::string* release_uniqueobjectidentifier();
  void set_allocated_uniqueobjectidentifier(std::string* uniqueobjectidentifier);
  private:
  const std::string& _internal_uniqueobjectidentifier() const;
  void _internal_set_uniqueobjectidentifier(const std::string& value);
  std::string* _internal_mutable_uniqueobjectidentifier();
  public:

  // string Semantic = 13;
  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:

  // string UnitAsString = 14;
  void clear_unitasstring();
  const std::string& unitasstring() const;
  void set_unitasstring(const std::string& value);
  void set_unitasstring(std::string&& value);
  void set_unitasstring(const char* value);
  void set_unitasstring(const char* value, size_t size);
  std::string* mutable_unitasstring();
  std::string* release_unitasstring();
  void set_allocated_unitasstring(std::string* unitasstring);
  private:
  const std::string& _internal_unitasstring() const;
  void _internal_set_unitasstring(const std::string& value);
  std::string* _internal_mutable_unitasstring();
  public:

  // string PhysicalDefaultValueAsString = 15;
  void clear_physicaldefaultvalueasstring();
  const std::string& physicaldefaultvalueasstring() const;
  void set_physicaldefaultvalueasstring(const std::string& value);
  void set_physicaldefaultvalueasstring(std::string&& value);
  void set_physicaldefaultvalueasstring(const char* value);
  void set_physicaldefaultvalueasstring(const char* value, size_t size);
  std::string* mutable_physicaldefaultvalueasstring();
  std::string* release_physicaldefaultvalueasstring();
  void set_allocated_physicaldefaultvalueasstring(std::string* physicaldefaultvalueasstring);
  private:
  const std::string& _internal_physicaldefaultvalueasstring() const;
  void _internal_set_physicaldefaultvalueasstring(const std::string& value);
  std::string* _internal_mutable_physicaldefaultvalueasstring();
  public:

  // string ReadAudienceState = 16;
  void clear_readaudiencestate();
  const std::string& readaudiencestate() const;
  void set_readaudiencestate(const std::string& value);
  void set_readaudiencestate(std::string&& value);
  void set_readaudiencestate(const char* value);
  void set_readaudiencestate(const char* value, size_t size);
  std::string* mutable_readaudiencestate();
  std::string* release_readaudiencestate();
  void set_allocated_readaudiencestate(std::string* readaudiencestate);
  private:
  const std::string& _internal_readaudiencestate() const;
  void _internal_set_readaudiencestate(const std::string& value);
  std::string* _internal_mutable_readaudiencestate();
  public:

  // string WriteAudienceState = 17;
  void clear_writeaudiencestate();
  const std::string& writeaudiencestate() const;
  void set_writeaudiencestate(const std::string& value);
  void set_writeaudiencestate(std::string&& value);
  void set_writeaudiencestate(const char* value);
  void set_writeaudiencestate(const char* value, size_t size);
  std::string* mutable_writeaudiencestate();
  std::string* release_writeaudiencestate();
  void set_allocated_writeaudiencestate(std::string* writeaudiencestate);
  private:
  const std::string& _internal_writeaudiencestate() const;
  void _internal_set_writeaudiencestate(const std::string& value);
  std::string* _internal_mutable_writeaudiencestate();
  public:

  // .OpenTestSystem.OtxDiagManager.Common.DIntervalPb Interval = 11;
  bool has_interval() const;
  private:
  bool _internal_has_interval() const;
  public:
  void clear_interval();
  const ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb& interval() const;
  ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb* release_interval();
  ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb* mutable_interval();
  void set_allocated_interval(::OpenTestSystem::OtxDiagManager::Common::DIntervalPb* interval);
  private:
  const ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb& _internal_interval() const;
  ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb* _internal_mutable_interval();
  public:

  // int32 ObjectType = 7;
  void clear_objecttype();
  ::PROTOBUF_NAMESPACE_ID::int32 objecttype() const;
  void set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_objecttype() const;
  void _internal_set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // uint32 BitLength = 8;
  void clear_bitlength();
  ::PROTOBUF_NAMESPACE_ID::uint32 bitlength() const;
  void set_bitlength(::PROTOBUF_NAMESPACE_ID::uint32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_bitlength() const;
  void _internal_set_bitlength(::PROTOBUF_NAMESPACE_ID::uint32 value);
  public:

  // int32 BitPosition = 9;
  void clear_bitposition();
  ::PROTOBUF_NAMESPACE_ID::int32 bitposition() const;
  void set_bitposition(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_bitposition() const;
  void _internal_set_bitposition(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 DecimalPlaces = 10;
  void clear_decimalplaces();
  ::PROTOBUF_NAMESPACE_ID::int32 decimalplaces() const;
  void set_decimalplaces(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_decimalplaces() const;
  void _internal_set_decimalplaces(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

  // int32 DataType = 12;
  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:

  // bool IsComplex = 20;
  void clear_iscomplex();
  bool iscomplex() const;
  void set_iscomplex(bool value);
  private:
  bool _internal_iscomplex() const;
  void _internal_set_iscomplex(bool value);
  public:

  // int32 BytePosition = 21;
  void clear_byteposition();
  ::PROTOBUF_NAMESPACE_ID::int32 byteposition() const;
  void set_byteposition(::PROTOBUF_NAMESPACE_ID::int32 value);
  private:
  ::PROTOBUF_NAMESPACE_ID::int32 _internal_byteposition() const;
  void _internal_set_byteposition(::PROTOBUF_NAMESPACE_ID::int32 value);
  public:

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

  ::PROTOBUF_NAMESPACE_ID::internal::InternalMetadataWithArena _internal_metadata_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb > dbitemvalues_;
  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb > texttableelements_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr descriptionid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr longname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr longnameid_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr shortname_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr uniqueobjectidentifier_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr semantic_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr unitasstring_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr physicaldefaultvalueasstring_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr readaudiencestate_;
  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr writeaudiencestate_;
  ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb* interval_;
  ::PROTOBUF_NAMESPACE_ID::int32 objecttype_;
  ::PROTOBUF_NAMESPACE_ID::uint32 bitlength_;
  ::PROTOBUF_NAMESPACE_ID::int32 bitposition_;
  ::PROTOBUF_NAMESPACE_ID::int32 decimalplaces_;
  ::PROTOBUF_NAMESPACE_ID::int32 datatype_;
  bool iscomplex_;
  ::PROTOBUF_NAMESPACE_ID::int32 byteposition_;
  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
  friend struct ::TableStruct_EcuConfigurationDataModelsPb_2eproto;
};
// ===================================================================


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

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

// .OpenTestSystem.OtxDiagManager.Common.DDbComChannelPb DbComChannel = 1;
inline bool DDbConfigurationDataPb::_internal_has_dbcomchannel() const {
  return this != internal_default_instance() && dbcomchannel_ != nullptr;
}
inline bool DDbConfigurationDataPb::has_dbcomchannel() const {
  return _internal_has_dbcomchannel();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb& DDbConfigurationDataPb::_internal_dbcomchannel() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb* p = dbcomchannel_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDbComChannelPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb& DDbConfigurationDataPb::dbcomchannel() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DbComChannel)
  return _internal_dbcomchannel();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb* DDbConfigurationDataPb::release_dbcomchannel() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DbComChannel)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb* temp = dbcomchannel_;
  dbcomchannel_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb* DDbConfigurationDataPb::_internal_mutable_dbcomchannel() {
  
  if (dbcomchannel_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb>(GetArenaNoVirtual());
    dbcomchannel_ = p;
  }
  return dbcomchannel_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb* DDbConfigurationDataPb::mutable_dbcomchannel() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DbComChannel)
  return _internal_mutable_dbcomchannel();
}
inline void DDbConfigurationDataPb::set_allocated_dbcomchannel(::OpenTestSystem::OtxDiagManager::Common::DDbComChannelPb* dbcomchannel) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(dbcomchannel_);
  }
  if (dbcomchannel) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      dbcomchannel = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dbcomchannel, submessage_arena);
    }
    
  } else {
    
  }
  dbcomchannel_ = dbcomchannel;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DbComChannel)
}

// string Description = 2;
inline void DDbConfigurationDataPb::clear_description() {
  description_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationDataPb::description() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.Description)
  return _internal_description();
}
inline void DDbConfigurationDataPb::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.Description)
}
inline std::string* DDbConfigurationDataPb::mutable_description() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.Description)
  return _internal_mutable_description();
}
inline const std::string& DDbConfigurationDataPb::_internal_description() const {
  return description_.GetNoArena();
}
inline void DDbConfigurationDataPb::_internal_set_description(const std::string& value) {
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationDataPb::set_description(std::string&& value) {
  
  description_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.Description)
}
inline void DDbConfigurationDataPb::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.Description)
}
inline void DDbConfigurationDataPb::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.Description)
}
inline std::string* DDbConfigurationDataPb::_internal_mutable_description() {
  
  return description_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationDataPb::release_description() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.Description)
  
  return description_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationDataPb::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.Description)
}

// string DescriptionID = 3;
inline void DDbConfigurationDataPb::clear_descriptionid() {
  descriptionid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationDataPb::descriptionid() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DescriptionID)
  return _internal_descriptionid();
}
inline void DDbConfigurationDataPb::set_descriptionid(const std::string& value) {
  _internal_set_descriptionid(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DescriptionID)
}
inline std::string* DDbConfigurationDataPb::mutable_descriptionid() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DescriptionID)
  return _internal_mutable_descriptionid();
}
inline const std::string& DDbConfigurationDataPb::_internal_descriptionid() const {
  return descriptionid_.GetNoArena();
}
inline void DDbConfigurationDataPb::_internal_set_descriptionid(const std::string& value) {
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationDataPb::set_descriptionid(std::string&& value) {
  
  descriptionid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DescriptionID)
}
inline void DDbConfigurationDataPb::set_descriptionid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DescriptionID)
}
inline void DDbConfigurationDataPb::set_descriptionid(const char* value, size_t size) {
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DescriptionID)
}
inline std::string* DDbConfigurationDataPb::_internal_mutable_descriptionid() {
  
  return descriptionid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationDataPb::release_descriptionid() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DescriptionID)
  
  return descriptionid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationDataPb::set_allocated_descriptionid(std::string* descriptionid) {
  if (descriptionid != nullptr) {
    
  } else {
    
  }
  descriptionid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), descriptionid);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.DescriptionID)
}

// string LongName = 4;
inline void DDbConfigurationDataPb::clear_longname() {
  longname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationDataPb::longname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongName)
  return _internal_longname();
}
inline void DDbConfigurationDataPb::set_longname(const std::string& value) {
  _internal_set_longname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongName)
}
inline std::string* DDbConfigurationDataPb::mutable_longname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongName)
  return _internal_mutable_longname();
}
inline const std::string& DDbConfigurationDataPb::_internal_longname() const {
  return longname_.GetNoArena();
}
inline void DDbConfigurationDataPb::_internal_set_longname(const std::string& value) {
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationDataPb::set_longname(std::string&& value) {
  
  longname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongName)
}
inline void DDbConfigurationDataPb::set_longname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongName)
}
inline void DDbConfigurationDataPb::set_longname(const char* value, size_t size) {
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongName)
}
inline std::string* DDbConfigurationDataPb::_internal_mutable_longname() {
  
  return longname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationDataPb::release_longname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongName)
  
  return longname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationDataPb::set_allocated_longname(std::string* longname) {
  if (longname != nullptr) {
    
  } else {
    
  }
  longname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), longname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongName)
}

// string LongNameID = 5;
inline void DDbConfigurationDataPb::clear_longnameid() {
  longnameid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationDataPb::longnameid() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongNameID)
  return _internal_longnameid();
}
inline void DDbConfigurationDataPb::set_longnameid(const std::string& value) {
  _internal_set_longnameid(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongNameID)
}
inline std::string* DDbConfigurationDataPb::mutable_longnameid() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongNameID)
  return _internal_mutable_longnameid();
}
inline const std::string& DDbConfigurationDataPb::_internal_longnameid() const {
  return longnameid_.GetNoArena();
}
inline void DDbConfigurationDataPb::_internal_set_longnameid(const std::string& value) {
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationDataPb::set_longnameid(std::string&& value) {
  
  longnameid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongNameID)
}
inline void DDbConfigurationDataPb::set_longnameid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongNameID)
}
inline void DDbConfigurationDataPb::set_longnameid(const char* value, size_t size) {
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongNameID)
}
inline std::string* DDbConfigurationDataPb::_internal_mutable_longnameid() {
  
  return longnameid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationDataPb::release_longnameid() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongNameID)
  
  return longnameid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationDataPb::set_allocated_longnameid(std::string* longnameid) {
  if (longnameid != nullptr) {
    
  } else {
    
  }
  longnameid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), longnameid);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.LongNameID)
}

// string ShortName = 6;
inline void DDbConfigurationDataPb::clear_shortname() {
  shortname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationDataPb::shortname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.ShortName)
  return _internal_shortname();
}
inline void DDbConfigurationDataPb::set_shortname(const std::string& value) {
  _internal_set_shortname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.ShortName)
}
inline std::string* DDbConfigurationDataPb::mutable_shortname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.ShortName)
  return _internal_mutable_shortname();
}
inline const std::string& DDbConfigurationDataPb::_internal_shortname() const {
  return shortname_.GetNoArena();
}
inline void DDbConfigurationDataPb::_internal_set_shortname(const std::string& value) {
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationDataPb::set_shortname(std::string&& value) {
  
  shortname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.ShortName)
}
inline void DDbConfigurationDataPb::set_shortname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.ShortName)
}
inline void DDbConfigurationDataPb::set_shortname(const char* value, size_t size) {
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.ShortName)
}
inline std::string* DDbConfigurationDataPb::_internal_mutable_shortname() {
  
  return shortname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationDataPb::release_shortname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.ShortName)
  
  return shortname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationDataPb::set_allocated_shortname(std::string* shortname) {
  if (shortname != nullptr) {
    
  } else {
    
  }
  shortname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), shortname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.ShortName)
}

// string UniqueObjectIdentifier = 7;
inline void DDbConfigurationDataPb::clear_uniqueobjectidentifier() {
  uniqueobjectidentifier_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationDataPb::uniqueobjectidentifier() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.UniqueObjectIdentifier)
  return _internal_uniqueobjectidentifier();
}
inline void DDbConfigurationDataPb::set_uniqueobjectidentifier(const std::string& value) {
  _internal_set_uniqueobjectidentifier(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.UniqueObjectIdentifier)
}
inline std::string* DDbConfigurationDataPb::mutable_uniqueobjectidentifier() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.UniqueObjectIdentifier)
  return _internal_mutable_uniqueobjectidentifier();
}
inline const std::string& DDbConfigurationDataPb::_internal_uniqueobjectidentifier() const {
  return uniqueobjectidentifier_.GetNoArena();
}
inline void DDbConfigurationDataPb::_internal_set_uniqueobjectidentifier(const std::string& value) {
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationDataPb::set_uniqueobjectidentifier(std::string&& value) {
  
  uniqueobjectidentifier_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.UniqueObjectIdentifier)
}
inline void DDbConfigurationDataPb::set_uniqueobjectidentifier(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.UniqueObjectIdentifier)
}
inline void DDbConfigurationDataPb::set_uniqueobjectidentifier(const char* value, size_t size) {
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.UniqueObjectIdentifier)
}
inline std::string* DDbConfigurationDataPb::_internal_mutable_uniqueobjectidentifier() {
  
  return uniqueobjectidentifier_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationDataPb::release_uniqueobjectidentifier() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.UniqueObjectIdentifier)
  
  return uniqueobjectidentifier_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationDataPb::set_allocated_uniqueobjectidentifier(std::string* uniqueobjectidentifier) {
  if (uniqueobjectidentifier != nullptr) {
    
  } else {
    
  }
  uniqueobjectidentifier_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uniqueobjectidentifier);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.UniqueObjectIdentifier)
}

// int32 ObjectType = 8;
inline void DDbConfigurationDataPb::clear_objecttype() {
  objecttype_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbConfigurationDataPb::_internal_objecttype() const {
  return objecttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbConfigurationDataPb::objecttype() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.ObjectType)
  return _internal_objecttype();
}
inline void DDbConfigurationDataPb::_internal_set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  objecttype_ = value;
}
inline void DDbConfigurationDataPb::set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_objecttype(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb.ObjectType)
}

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

// DDbConfigurationRecordPb

// .OpenTestSystem.OtxDiagManager.Common.DDbConfigurationDataPb DbConfigurationData = 1;
inline bool DDbConfigurationRecordPb::_internal_has_dbconfigurationdata() const {
  return this != internal_default_instance() && dbconfigurationdata_ != nullptr;
}
inline bool DDbConfigurationRecordPb::has_dbconfigurationdata() const {
  return _internal_has_dbconfigurationdata();
}
inline void DDbConfigurationRecordPb::clear_dbconfigurationdata() {
  if (GetArenaNoVirtual() == nullptr && dbconfigurationdata_ != nullptr) {
    delete dbconfigurationdata_;
  }
  dbconfigurationdata_ = nullptr;
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb& DDbConfigurationRecordPb::_internal_dbconfigurationdata() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* p = dbconfigurationdata_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDbConfigurationDataPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb& DDbConfigurationRecordPb::dbconfigurationdata() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DbConfigurationData)
  return _internal_dbconfigurationdata();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* DDbConfigurationRecordPb::release_dbconfigurationdata() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DbConfigurationData)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* temp = dbconfigurationdata_;
  dbconfigurationdata_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* DDbConfigurationRecordPb::_internal_mutable_dbconfigurationdata() {
  
  if (dbconfigurationdata_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb>(GetArenaNoVirtual());
    dbconfigurationdata_ = p;
  }
  return dbconfigurationdata_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* DDbConfigurationRecordPb::mutable_dbconfigurationdata() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DbConfigurationData)
  return _internal_mutable_dbconfigurationdata();
}
inline void DDbConfigurationRecordPb::set_allocated_dbconfigurationdata(::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationDataPb* dbconfigurationdata) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete dbconfigurationdata_;
  }
  if (dbconfigurationdata) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      dbconfigurationdata = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dbconfigurationdata, submessage_arena);
    }
    
  } else {
    
  }
  dbconfigurationdata_ = dbconfigurationdata;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DbConfigurationData)
}

// string Description = 2;
inline void DDbConfigurationRecordPb::clear_description() {
  description_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationRecordPb::description() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.Description)
  return _internal_description();
}
inline void DDbConfigurationRecordPb::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.Description)
}
inline std::string* DDbConfigurationRecordPb::mutable_description() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.Description)
  return _internal_mutable_description();
}
inline const std::string& DDbConfigurationRecordPb::_internal_description() const {
  return description_.GetNoArena();
}
inline void DDbConfigurationRecordPb::_internal_set_description(const std::string& value) {
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationRecordPb::set_description(std::string&& value) {
  
  description_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.Description)
}
inline void DDbConfigurationRecordPb::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.Description)
}
inline void DDbConfigurationRecordPb::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.Description)
}
inline std::string* DDbConfigurationRecordPb::_internal_mutable_description() {
  
  return description_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationRecordPb::release_description() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.Description)
  
  return description_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationRecordPb::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.Description)
}

// string DescriptionID = 3;
inline void DDbConfigurationRecordPb::clear_descriptionid() {
  descriptionid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationRecordPb::descriptionid() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DescriptionID)
  return _internal_descriptionid();
}
inline void DDbConfigurationRecordPb::set_descriptionid(const std::string& value) {
  _internal_set_descriptionid(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DescriptionID)
}
inline std::string* DDbConfigurationRecordPb::mutable_descriptionid() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DescriptionID)
  return _internal_mutable_descriptionid();
}
inline const std::string& DDbConfigurationRecordPb::_internal_descriptionid() const {
  return descriptionid_.GetNoArena();
}
inline void DDbConfigurationRecordPb::_internal_set_descriptionid(const std::string& value) {
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationRecordPb::set_descriptionid(std::string&& value) {
  
  descriptionid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DescriptionID)
}
inline void DDbConfigurationRecordPb::set_descriptionid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DescriptionID)
}
inline void DDbConfigurationRecordPb::set_descriptionid(const char* value, size_t size) {
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DescriptionID)
}
inline std::string* DDbConfigurationRecordPb::_internal_mutable_descriptionid() {
  
  return descriptionid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationRecordPb::release_descriptionid() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DescriptionID)
  
  return descriptionid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationRecordPb::set_allocated_descriptionid(std::string* descriptionid) {
  if (descriptionid != nullptr) {
    
  } else {
    
  }
  descriptionid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), descriptionid);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.DescriptionID)
}

// string LongName = 4;
inline void DDbConfigurationRecordPb::clear_longname() {
  longname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationRecordPb::longname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongName)
  return _internal_longname();
}
inline void DDbConfigurationRecordPb::set_longname(const std::string& value) {
  _internal_set_longname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongName)
}
inline std::string* DDbConfigurationRecordPb::mutable_longname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongName)
  return _internal_mutable_longname();
}
inline const std::string& DDbConfigurationRecordPb::_internal_longname() const {
  return longname_.GetNoArena();
}
inline void DDbConfigurationRecordPb::_internal_set_longname(const std::string& value) {
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationRecordPb::set_longname(std::string&& value) {
  
  longname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongName)
}
inline void DDbConfigurationRecordPb::set_longname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongName)
}
inline void DDbConfigurationRecordPb::set_longname(const char* value, size_t size) {
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongName)
}
inline std::string* DDbConfigurationRecordPb::_internal_mutable_longname() {
  
  return longname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationRecordPb::release_longname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongName)
  
  return longname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationRecordPb::set_allocated_longname(std::string* longname) {
  if (longname != nullptr) {
    
  } else {
    
  }
  longname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), longname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongName)
}

// string LongNameID = 5;
inline void DDbConfigurationRecordPb::clear_longnameid() {
  longnameid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationRecordPb::longnameid() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongNameID)
  return _internal_longnameid();
}
inline void DDbConfigurationRecordPb::set_longnameid(const std::string& value) {
  _internal_set_longnameid(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongNameID)
}
inline std::string* DDbConfigurationRecordPb::mutable_longnameid() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongNameID)
  return _internal_mutable_longnameid();
}
inline const std::string& DDbConfigurationRecordPb::_internal_longnameid() const {
  return longnameid_.GetNoArena();
}
inline void DDbConfigurationRecordPb::_internal_set_longnameid(const std::string& value) {
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationRecordPb::set_longnameid(std::string&& value) {
  
  longnameid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongNameID)
}
inline void DDbConfigurationRecordPb::set_longnameid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongNameID)
}
inline void DDbConfigurationRecordPb::set_longnameid(const char* value, size_t size) {
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongNameID)
}
inline std::string* DDbConfigurationRecordPb::_internal_mutable_longnameid() {
  
  return longnameid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationRecordPb::release_longnameid() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongNameID)
  
  return longnameid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationRecordPb::set_allocated_longnameid(std::string* longnameid) {
  if (longnameid != nullptr) {
    
  } else {
    
  }
  longnameid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), longnameid);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.LongNameID)
}

// string ShortName = 6;
inline void DDbConfigurationRecordPb::clear_shortname() {
  shortname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationRecordPb::shortname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.ShortName)
  return _internal_shortname();
}
inline void DDbConfigurationRecordPb::set_shortname(const std::string& value) {
  _internal_set_shortname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.ShortName)
}
inline std::string* DDbConfigurationRecordPb::mutable_shortname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.ShortName)
  return _internal_mutable_shortname();
}
inline const std::string& DDbConfigurationRecordPb::_internal_shortname() const {
  return shortname_.GetNoArena();
}
inline void DDbConfigurationRecordPb::_internal_set_shortname(const std::string& value) {
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationRecordPb::set_shortname(std::string&& value) {
  
  shortname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.ShortName)
}
inline void DDbConfigurationRecordPb::set_shortname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.ShortName)
}
inline void DDbConfigurationRecordPb::set_shortname(const char* value, size_t size) {
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.ShortName)
}
inline std::string* DDbConfigurationRecordPb::_internal_mutable_shortname() {
  
  return shortname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationRecordPb::release_shortname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.ShortName)
  
  return shortname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationRecordPb::set_allocated_shortname(std::string* shortname) {
  if (shortname != nullptr) {
    
  } else {
    
  }
  shortname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), shortname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.ShortName)
}

// string UniqueObjectIdentifier = 7;
inline void DDbConfigurationRecordPb::clear_uniqueobjectidentifier() {
  uniqueobjectidentifier_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbConfigurationRecordPb::uniqueobjectidentifier() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.UniqueObjectIdentifier)
  return _internal_uniqueobjectidentifier();
}
inline void DDbConfigurationRecordPb::set_uniqueobjectidentifier(const std::string& value) {
  _internal_set_uniqueobjectidentifier(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.UniqueObjectIdentifier)
}
inline std::string* DDbConfigurationRecordPb::mutable_uniqueobjectidentifier() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.UniqueObjectIdentifier)
  return _internal_mutable_uniqueobjectidentifier();
}
inline const std::string& DDbConfigurationRecordPb::_internal_uniqueobjectidentifier() const {
  return uniqueobjectidentifier_.GetNoArena();
}
inline void DDbConfigurationRecordPb::_internal_set_uniqueobjectidentifier(const std::string& value) {
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbConfigurationRecordPb::set_uniqueobjectidentifier(std::string&& value) {
  
  uniqueobjectidentifier_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.UniqueObjectIdentifier)
}
inline void DDbConfigurationRecordPb::set_uniqueobjectidentifier(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.UniqueObjectIdentifier)
}
inline void DDbConfigurationRecordPb::set_uniqueobjectidentifier(const char* value, size_t size) {
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.UniqueObjectIdentifier)
}
inline std::string* DDbConfigurationRecordPb::_internal_mutable_uniqueobjectidentifier() {
  
  return uniqueobjectidentifier_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbConfigurationRecordPb::release_uniqueobjectidentifier() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.UniqueObjectIdentifier)
  
  return uniqueobjectidentifier_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbConfigurationRecordPb::set_allocated_uniqueobjectidentifier(std::string* uniqueobjectidentifier) {
  if (uniqueobjectidentifier != nullptr) {
    
  } else {
    
  }
  uniqueobjectidentifier_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uniqueobjectidentifier);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.UniqueObjectIdentifier)
}

// int32 ObjectType = 8;
inline void DDbConfigurationRecordPb::clear_objecttype() {
  objecttype_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbConfigurationRecordPb::_internal_objecttype() const {
  return objecttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbConfigurationRecordPb::objecttype() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.ObjectType)
  return _internal_objecttype();
}
inline void DDbConfigurationRecordPb::_internal_set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  objecttype_ = value;
}
inline void DDbConfigurationRecordPb::set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_objecttype(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb.ObjectType)
}

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

// DDbDataRecordPb

// .OpenTestSystem.OtxDiagManager.Common.DDbConfigurationRecordPb DbConfigurationRecord = 1;
inline bool DDbDataRecordPb::_internal_has_dbconfigurationrecord() const {
  return this != internal_default_instance() && dbconfigurationrecord_ != nullptr;
}
inline bool DDbDataRecordPb::has_dbconfigurationrecord() const {
  return _internal_has_dbconfigurationrecord();
}
inline void DDbDataRecordPb::clear_dbconfigurationrecord() {
  if (GetArenaNoVirtual() == nullptr && dbconfigurationrecord_ != nullptr) {
    delete dbconfigurationrecord_;
  }
  dbconfigurationrecord_ = nullptr;
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb& DDbDataRecordPb::_internal_dbconfigurationrecord() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* p = dbconfigurationrecord_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DDbConfigurationRecordPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb& DDbDataRecordPb::dbconfigurationrecord() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DbConfigurationRecord)
  return _internal_dbconfigurationrecord();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* DDbDataRecordPb::release_dbconfigurationrecord() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DbConfigurationRecord)
  
  ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* temp = dbconfigurationrecord_;
  dbconfigurationrecord_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* DDbDataRecordPb::_internal_mutable_dbconfigurationrecord() {
  
  if (dbconfigurationrecord_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb>(GetArenaNoVirtual());
    dbconfigurationrecord_ = p;
  }
  return dbconfigurationrecord_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* DDbDataRecordPb::mutable_dbconfigurationrecord() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DbConfigurationRecord)
  return _internal_mutable_dbconfigurationrecord();
}
inline void DDbDataRecordPb::set_allocated_dbconfigurationrecord(::OpenTestSystem::OtxDiagManager::Common::DDbConfigurationRecordPb* dbconfigurationrecord) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete dbconfigurationrecord_;
  }
  if (dbconfigurationrecord) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      dbconfigurationrecord = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, dbconfigurationrecord, submessage_arena);
    }
    
  } else {
    
  }
  dbconfigurationrecord_ = dbconfigurationrecord;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DbConfigurationRecord)
}

// string Description = 2;
inline void DDbDataRecordPb::clear_description() {
  description_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbDataRecordPb::description() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Description)
  return _internal_description();
}
inline void DDbDataRecordPb::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Description)
}
inline std::string* DDbDataRecordPb::mutable_description() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Description)
  return _internal_mutable_description();
}
inline const std::string& DDbDataRecordPb::_internal_description() const {
  return description_.GetNoArena();
}
inline void DDbDataRecordPb::_internal_set_description(const std::string& value) {
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbDataRecordPb::set_description(std::string&& value) {
  
  description_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Description)
}
inline void DDbDataRecordPb::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Description)
}
inline void DDbDataRecordPb::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Description)
}
inline std::string* DDbDataRecordPb::_internal_mutable_description() {
  
  return description_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbDataRecordPb::release_description() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Description)
  
  return description_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbDataRecordPb::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Description)
}

// string DescriptionID = 3;
inline void DDbDataRecordPb::clear_descriptionid() {
  descriptionid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbDataRecordPb::descriptionid() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DescriptionID)
  return _internal_descriptionid();
}
inline void DDbDataRecordPb::set_descriptionid(const std::string& value) {
  _internal_set_descriptionid(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DescriptionID)
}
inline std::string* DDbDataRecordPb::mutable_descriptionid() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DescriptionID)
  return _internal_mutable_descriptionid();
}
inline const std::string& DDbDataRecordPb::_internal_descriptionid() const {
  return descriptionid_.GetNoArena();
}
inline void DDbDataRecordPb::_internal_set_descriptionid(const std::string& value) {
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbDataRecordPb::set_descriptionid(std::string&& value) {
  
  descriptionid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DescriptionID)
}
inline void DDbDataRecordPb::set_descriptionid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DescriptionID)
}
inline void DDbDataRecordPb::set_descriptionid(const char* value, size_t size) {
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DescriptionID)
}
inline std::string* DDbDataRecordPb::_internal_mutable_descriptionid() {
  
  return descriptionid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbDataRecordPb::release_descriptionid() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DescriptionID)
  
  return descriptionid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbDataRecordPb::set_allocated_descriptionid(std::string* descriptionid) {
  if (descriptionid != nullptr) {
    
  } else {
    
  }
  descriptionid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), descriptionid);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DescriptionID)
}

// string LongName = 4;
inline void DDbDataRecordPb::clear_longname() {
  longname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbDataRecordPb::longname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongName)
  return _internal_longname();
}
inline void DDbDataRecordPb::set_longname(const std::string& value) {
  _internal_set_longname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongName)
}
inline std::string* DDbDataRecordPb::mutable_longname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongName)
  return _internal_mutable_longname();
}
inline const std::string& DDbDataRecordPb::_internal_longname() const {
  return longname_.GetNoArena();
}
inline void DDbDataRecordPb::_internal_set_longname(const std::string& value) {
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbDataRecordPb::set_longname(std::string&& value) {
  
  longname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongName)
}
inline void DDbDataRecordPb::set_longname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongName)
}
inline void DDbDataRecordPb::set_longname(const char* value, size_t size) {
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongName)
}
inline std::string* DDbDataRecordPb::_internal_mutable_longname() {
  
  return longname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbDataRecordPb::release_longname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongName)
  
  return longname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbDataRecordPb::set_allocated_longname(std::string* longname) {
  if (longname != nullptr) {
    
  } else {
    
  }
  longname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), longname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongName)
}

// string LongNameID = 5;
inline void DDbDataRecordPb::clear_longnameid() {
  longnameid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbDataRecordPb::longnameid() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongNameID)
  return _internal_longnameid();
}
inline void DDbDataRecordPb::set_longnameid(const std::string& value) {
  _internal_set_longnameid(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongNameID)
}
inline std::string* DDbDataRecordPb::mutable_longnameid() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongNameID)
  return _internal_mutable_longnameid();
}
inline const std::string& DDbDataRecordPb::_internal_longnameid() const {
  return longnameid_.GetNoArena();
}
inline void DDbDataRecordPb::_internal_set_longnameid(const std::string& value) {
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbDataRecordPb::set_longnameid(std::string&& value) {
  
  longnameid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongNameID)
}
inline void DDbDataRecordPb::set_longnameid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongNameID)
}
inline void DDbDataRecordPb::set_longnameid(const char* value, size_t size) {
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongNameID)
}
inline std::string* DDbDataRecordPb::_internal_mutable_longnameid() {
  
  return longnameid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbDataRecordPb::release_longnameid() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongNameID)
  
  return longnameid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbDataRecordPb::set_allocated_longnameid(std::string* longnameid) {
  if (longnameid != nullptr) {
    
  } else {
    
  }
  longnameid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), longnameid);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.LongNameID)
}

// string ShortName = 6;
inline void DDbDataRecordPb::clear_shortname() {
  shortname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbDataRecordPb::shortname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.ShortName)
  return _internal_shortname();
}
inline void DDbDataRecordPb::set_shortname(const std::string& value) {
  _internal_set_shortname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.ShortName)
}
inline std::string* DDbDataRecordPb::mutable_shortname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.ShortName)
  return _internal_mutable_shortname();
}
inline const std::string& DDbDataRecordPb::_internal_shortname() const {
  return shortname_.GetNoArena();
}
inline void DDbDataRecordPb::_internal_set_shortname(const std::string& value) {
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbDataRecordPb::set_shortname(std::string&& value) {
  
  shortname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.ShortName)
}
inline void DDbDataRecordPb::set_shortname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.ShortName)
}
inline void DDbDataRecordPb::set_shortname(const char* value, size_t size) {
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.ShortName)
}
inline std::string* DDbDataRecordPb::_internal_mutable_shortname() {
  
  return shortname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbDataRecordPb::release_shortname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.ShortName)
  
  return shortname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbDataRecordPb::set_allocated_shortname(std::string* shortname) {
  if (shortname != nullptr) {
    
  } else {
    
  }
  shortname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), shortname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.ShortName)
}

// string UniqueObjectIdentifier = 7;
inline void DDbDataRecordPb::clear_uniqueobjectidentifier() {
  uniqueobjectidentifier_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbDataRecordPb::uniqueobjectidentifier() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.UniqueObjectIdentifier)
  return _internal_uniqueobjectidentifier();
}
inline void DDbDataRecordPb::set_uniqueobjectidentifier(const std::string& value) {
  _internal_set_uniqueobjectidentifier(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.UniqueObjectIdentifier)
}
inline std::string* DDbDataRecordPb::mutable_uniqueobjectidentifier() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.UniqueObjectIdentifier)
  return _internal_mutable_uniqueobjectidentifier();
}
inline const std::string& DDbDataRecordPb::_internal_uniqueobjectidentifier() const {
  return uniqueobjectidentifier_.GetNoArena();
}
inline void DDbDataRecordPb::_internal_set_uniqueobjectidentifier(const std::string& value) {
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbDataRecordPb::set_uniqueobjectidentifier(std::string&& value) {
  
  uniqueobjectidentifier_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.UniqueObjectIdentifier)
}
inline void DDbDataRecordPb::set_uniqueobjectidentifier(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.UniqueObjectIdentifier)
}
inline void DDbDataRecordPb::set_uniqueobjectidentifier(const char* value, size_t size) {
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.UniqueObjectIdentifier)
}
inline std::string* DDbDataRecordPb::_internal_mutable_uniqueobjectidentifier() {
  
  return uniqueobjectidentifier_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbDataRecordPb::release_uniqueobjectidentifier() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.UniqueObjectIdentifier)
  
  return uniqueobjectidentifier_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbDataRecordPb::set_allocated_uniqueobjectidentifier(std::string* uniqueobjectidentifier) {
  if (uniqueobjectidentifier != nullptr) {
    
  } else {
    
  }
  uniqueobjectidentifier_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uniqueobjectidentifier);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.UniqueObjectIdentifier)
}

// int32 ObjectType = 8;
inline void DDbDataRecordPb::clear_objecttype() {
  objecttype_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbDataRecordPb::_internal_objecttype() const {
  return objecttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbDataRecordPb::objecttype() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.ObjectType)
  return _internal_objecttype();
}
inline void DDbDataRecordPb::_internal_set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  objecttype_ = value;
}
inline void DDbDataRecordPb::set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_objecttype(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.ObjectType)
}

// string DataId = 9;
inline bool DDbDataRecordPb::_internal_has_dataid() const {
  return kind_case() == kDataId;
}
inline void DDbDataRecordPb::set_has_dataid() {
  _oneof_case_[0] = kDataId;
}
inline void DDbDataRecordPb::clear_dataid() {
  if (_internal_has_dataid()) {
    kind_.dataid_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
    clear_has_kind();
  }
}
inline const std::string& DDbDataRecordPb::dataid() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DataId)
  return _internal_dataid();
}
inline void DDbDataRecordPb::set_dataid(const std::string& value) {
  _internal_set_dataid(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DataId)
}
inline std::string* DDbDataRecordPb::mutable_dataid() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DataId)
  return _internal_mutable_dataid();
}
inline const std::string& DDbDataRecordPb::_internal_dataid() const {
  if (_internal_has_dataid()) {
    return kind_.dataid_.GetNoArena();
  }
  return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void DDbDataRecordPb::_internal_set_dataid(const std::string& value) {
  if (!_internal_has_dataid()) {
    clear_kind();
    set_has_dataid();
    kind_.dataid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.dataid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbDataRecordPb::set_dataid(std::string&& value) {
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DataId)
  if (!_internal_has_dataid()) {
    clear_kind();
    set_has_dataid();
    kind_.dataid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.dataid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DataId)
}
inline void DDbDataRecordPb::set_dataid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  if (!_internal_has_dataid()) {
    clear_kind();
    set_has_dataid();
    kind_.dataid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.dataid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DataId)
}
inline void DDbDataRecordPb::set_dataid(const char* value, size_t size) {
  if (!_internal_has_dataid()) {
    clear_kind();
    set_has_dataid();
    kind_.dataid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.dataid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DataId)
}
inline std::string* DDbDataRecordPb::_internal_mutable_dataid() {
  if (!_internal_has_dataid()) {
    clear_kind();
    set_has_dataid();
    kind_.dataid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return kind_.dataid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbDataRecordPb::release_dataid() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DataId)
  if (_internal_has_dataid()) {
    clear_has_kind();
    return kind_.dataid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  } else {
    return nullptr;
  }
}
inline void DDbDataRecordPb::set_allocated_dataid(std::string* dataid) {
  if (has_kind()) {
    clear_kind();
  }
  if (dataid != nullptr) {
    set_has_dataid();
    kind_.dataid_.UnsafeSetDefault(dataid);
  }
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.DataId)
}

// string Key = 10;
inline bool DDbDataRecordPb::_internal_has_key() const {
  return kind_case() == kKey;
}
inline void DDbDataRecordPb::set_has_key() {
  _oneof_case_[0] = kKey;
}
inline void DDbDataRecordPb::clear_key() {
  if (_internal_has_key()) {
    kind_.key_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
    clear_has_kind();
  }
}
inline const std::string& DDbDataRecordPb::key() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Key)
  return _internal_key();
}
inline void DDbDataRecordPb::set_key(const std::string& value) {
  _internal_set_key(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Key)
}
inline std::string* DDbDataRecordPb::mutable_key() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Key)
  return _internal_mutable_key();
}
inline const std::string& DDbDataRecordPb::_internal_key() const {
  if (_internal_has_key()) {
    return kind_.key_.GetNoArena();
  }
  return *&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
}
inline void DDbDataRecordPb::_internal_set_key(const std::string& value) {
  if (!_internal_has_key()) {
    clear_kind();
    set_has_key();
    kind_.key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbDataRecordPb::set_key(std::string&& value) {
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Key)
  if (!_internal_has_key()) {
    clear_kind();
    set_has_key();
    kind_.key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Key)
}
inline void DDbDataRecordPb::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  if (!_internal_has_key()) {
    clear_kind();
    set_has_key();
    kind_.key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Key)
}
inline void DDbDataRecordPb::set_key(const char* value, size_t size) {
  if (!_internal_has_key()) {
    clear_kind();
    set_has_key();
    kind_.key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  kind_.key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(
      reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Key)
}
inline std::string* DDbDataRecordPb::_internal_mutable_key() {
  if (!_internal_has_key()) {
    clear_kind();
    set_has_key();
    kind_.key_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  }
  return kind_.key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbDataRecordPb::release_key() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Key)
  if (_internal_has_key()) {
    clear_has_kind();
    return kind_.key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
  } else {
    return nullptr;
  }
}
inline void DDbDataRecordPb::set_allocated_key(std::string* key) {
  if (has_kind()) {
    clear_kind();
  }
  if (key != nullptr) {
    set_has_key();
    kind_.key_.UnsafeSetDefault(key);
  }
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbDataRecordPb.Key)
}

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

// DDbItemValuePb

// string Key = 1;
inline void DDbItemValuePb::clear_key() {
  key_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbItemValuePb::key() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Key)
  return _internal_key();
}
inline void DDbItemValuePb::set_key(const std::string& value) {
  _internal_set_key(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Key)
}
inline std::string* DDbItemValuePb::mutable_key() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Key)
  return _internal_mutable_key();
}
inline const std::string& DDbItemValuePb::_internal_key() const {
  return key_.GetNoArena();
}
inline void DDbItemValuePb::_internal_set_key(const std::string& value) {
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbItemValuePb::set_key(std::string&& value) {
  
  key_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Key)
}
inline void DDbItemValuePb::set_key(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Key)
}
inline void DDbItemValuePb::set_key(const char* value, size_t size) {
  
  key_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Key)
}
inline std::string* DDbItemValuePb::_internal_mutable_key() {
  
  return key_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbItemValuePb::release_key() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Key)
  
  return key_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbItemValuePb::set_allocated_key(std::string* key) {
  if (key != nullptr) {
    
  } else {
    
  }
  key_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Key)
}

// string Meaning = 2;
inline void DDbItemValuePb::clear_meaning() {
  meaning_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbItemValuePb::meaning() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Meaning)
  return _internal_meaning();
}
inline void DDbItemValuePb::set_meaning(const std::string& value) {
  _internal_set_meaning(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Meaning)
}
inline std::string* DDbItemValuePb::mutable_meaning() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Meaning)
  return _internal_mutable_meaning();
}
inline const std::string& DDbItemValuePb::_internal_meaning() const {
  return meaning_.GetNoArena();
}
inline void DDbItemValuePb::_internal_set_meaning(const std::string& value) {
  
  meaning_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbItemValuePb::set_meaning(std::string&& value) {
  
  meaning_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Meaning)
}
inline void DDbItemValuePb::set_meaning(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  meaning_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Meaning)
}
inline void DDbItemValuePb::set_meaning(const char* value, size_t size) {
  
  meaning_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Meaning)
}
inline std::string* DDbItemValuePb::_internal_mutable_meaning() {
  
  return meaning_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbItemValuePb::release_meaning() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Meaning)
  
  return meaning_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbItemValuePb::set_allocated_meaning(std::string* meaning) {
  if (meaning != nullptr) {
    
  } else {
    
  }
  meaning_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), meaning);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Meaning)
}

// string MeaningId = 3;
inline void DDbItemValuePb::clear_meaningid() {
  meaningid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbItemValuePb::meaningid() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.MeaningId)
  return _internal_meaningid();
}
inline void DDbItemValuePb::set_meaningid(const std::string& value) {
  _internal_set_meaningid(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.MeaningId)
}
inline std::string* DDbItemValuePb::mutable_meaningid() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.MeaningId)
  return _internal_mutable_meaningid();
}
inline const std::string& DDbItemValuePb::_internal_meaningid() const {
  return meaningid_.GetNoArena();
}
inline void DDbItemValuePb::_internal_set_meaningid(const std::string& value) {
  
  meaningid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbItemValuePb::set_meaningid(std::string&& value) {
  
  meaningid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.MeaningId)
}
inline void DDbItemValuePb::set_meaningid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  meaningid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.MeaningId)
}
inline void DDbItemValuePb::set_meaningid(const char* value, size_t size) {
  
  meaningid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.MeaningId)
}
inline std::string* DDbItemValuePb::_internal_mutable_meaningid() {
  
  return meaningid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbItemValuePb::release_meaningid() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.MeaningId)
  
  return meaningid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbItemValuePb::set_allocated_meaningid(std::string* meaningid) {
  if (meaningid != nullptr) {
    
  } else {
    
  }
  meaningid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), meaningid);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.MeaningId)
}

// string PhysicalConstantValueAsString = 4;
inline void DDbItemValuePb::clear_physicalconstantvalueasstring() {
  physicalconstantvalueasstring_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbItemValuePb::physicalconstantvalueasstring() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.PhysicalConstantValueAsString)
  return _internal_physicalconstantvalueasstring();
}
inline void DDbItemValuePb::set_physicalconstantvalueasstring(const std::string& value) {
  _internal_set_physicalconstantvalueasstring(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.PhysicalConstantValueAsString)
}
inline std::string* DDbItemValuePb::mutable_physicalconstantvalueasstring() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.PhysicalConstantValueAsString)
  return _internal_mutable_physicalconstantvalueasstring();
}
inline const std::string& DDbItemValuePb::_internal_physicalconstantvalueasstring() const {
  return physicalconstantvalueasstring_.GetNoArena();
}
inline void DDbItemValuePb::_internal_set_physicalconstantvalueasstring(const std::string& value) {
  
  physicalconstantvalueasstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbItemValuePb::set_physicalconstantvalueasstring(std::string&& value) {
  
  physicalconstantvalueasstring_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.PhysicalConstantValueAsString)
}
inline void DDbItemValuePb::set_physicalconstantvalueasstring(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  physicalconstantvalueasstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.PhysicalConstantValueAsString)
}
inline void DDbItemValuePb::set_physicalconstantvalueasstring(const char* value, size_t size) {
  
  physicalconstantvalueasstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.PhysicalConstantValueAsString)
}
inline std::string* DDbItemValuePb::_internal_mutable_physicalconstantvalueasstring() {
  
  return physicalconstantvalueasstring_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbItemValuePb::release_physicalconstantvalueasstring() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.PhysicalConstantValueAsString)
  
  return physicalconstantvalueasstring_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbItemValuePb::set_allocated_physicalconstantvalueasstring(std::string* physicalconstantvalueasstring) {
  if (physicalconstantvalueasstring != nullptr) {
    
  } else {
    
  }
  physicalconstantvalueasstring_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), physicalconstantvalueasstring);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.PhysicalConstantValueAsString)
}

// string Rule = 5;
inline void DDbItemValuePb::clear_rule() {
  rule_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbItemValuePb::rule() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Rule)
  return _internal_rule();
}
inline void DDbItemValuePb::set_rule(const std::string& value) {
  _internal_set_rule(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Rule)
}
inline std::string* DDbItemValuePb::mutable_rule() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Rule)
  return _internal_mutable_rule();
}
inline const std::string& DDbItemValuePb::_internal_rule() const {
  return rule_.GetNoArena();
}
inline void DDbItemValuePb::_internal_set_rule(const std::string& value) {
  
  rule_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbItemValuePb::set_rule(std::string&& value) {
  
  rule_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Rule)
}
inline void DDbItemValuePb::set_rule(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  rule_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Rule)
}
inline void DDbItemValuePb::set_rule(const char* value, size_t size) {
  
  rule_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Rule)
}
inline std::string* DDbItemValuePb::_internal_mutable_rule() {
  
  return rule_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbItemValuePb::release_rule() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Rule)
  
  return rule_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbItemValuePb::set_allocated_rule(std::string* rule) {
  if (rule != nullptr) {
    
  } else {
    
  }
  rule_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rule);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb.Rule)
}

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

// DDbOptionItemPb

// string Description = 1;
inline void DDbOptionItemPb::clear_description() {
  description_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbOptionItemPb::description() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Description)
  return _internal_description();
}
inline void DDbOptionItemPb::set_description(const std::string& value) {
  _internal_set_description(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Description)
}
inline std::string* DDbOptionItemPb::mutable_description() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Description)
  return _internal_mutable_description();
}
inline const std::string& DDbOptionItemPb::_internal_description() const {
  return description_.GetNoArena();
}
inline void DDbOptionItemPb::_internal_set_description(const std::string& value) {
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbOptionItemPb::set_description(std::string&& value) {
  
  description_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Description)
}
inline void DDbOptionItemPb::set_description(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Description)
}
inline void DDbOptionItemPb::set_description(const char* value, size_t size) {
  
  description_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Description)
}
inline std::string* DDbOptionItemPb::_internal_mutable_description() {
  
  return description_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbOptionItemPb::release_description() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Description)
  
  return description_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbOptionItemPb::set_allocated_description(std::string* description) {
  if (description != nullptr) {
    
  } else {
    
  }
  description_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Description)
}

// string DescriptionID = 2;
inline void DDbOptionItemPb::clear_descriptionid() {
  descriptionid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbOptionItemPb::descriptionid() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DescriptionID)
  return _internal_descriptionid();
}
inline void DDbOptionItemPb::set_descriptionid(const std::string& value) {
  _internal_set_descriptionid(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DescriptionID)
}
inline std::string* DDbOptionItemPb::mutable_descriptionid() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DescriptionID)
  return _internal_mutable_descriptionid();
}
inline const std::string& DDbOptionItemPb::_internal_descriptionid() const {
  return descriptionid_.GetNoArena();
}
inline void DDbOptionItemPb::_internal_set_descriptionid(const std::string& value) {
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbOptionItemPb::set_descriptionid(std::string&& value) {
  
  descriptionid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DescriptionID)
}
inline void DDbOptionItemPb::set_descriptionid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DescriptionID)
}
inline void DDbOptionItemPb::set_descriptionid(const char* value, size_t size) {
  
  descriptionid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DescriptionID)
}
inline std::string* DDbOptionItemPb::_internal_mutable_descriptionid() {
  
  return descriptionid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbOptionItemPb::release_descriptionid() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DescriptionID)
  
  return descriptionid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbOptionItemPb::set_allocated_descriptionid(std::string* descriptionid) {
  if (descriptionid != nullptr) {
    
  } else {
    
  }
  descriptionid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), descriptionid);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DescriptionID)
}

// string LongName = 3;
inline void DDbOptionItemPb::clear_longname() {
  longname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbOptionItemPb::longname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongName)
  return _internal_longname();
}
inline void DDbOptionItemPb::set_longname(const std::string& value) {
  _internal_set_longname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongName)
}
inline std::string* DDbOptionItemPb::mutable_longname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongName)
  return _internal_mutable_longname();
}
inline const std::string& DDbOptionItemPb::_internal_longname() const {
  return longname_.GetNoArena();
}
inline void DDbOptionItemPb::_internal_set_longname(const std::string& value) {
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbOptionItemPb::set_longname(std::string&& value) {
  
  longname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongName)
}
inline void DDbOptionItemPb::set_longname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongName)
}
inline void DDbOptionItemPb::set_longname(const char* value, size_t size) {
  
  longname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongName)
}
inline std::string* DDbOptionItemPb::_internal_mutable_longname() {
  
  return longname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbOptionItemPb::release_longname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongName)
  
  return longname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbOptionItemPb::set_allocated_longname(std::string* longname) {
  if (longname != nullptr) {
    
  } else {
    
  }
  longname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), longname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongName)
}

// string LongNameID = 4;
inline void DDbOptionItemPb::clear_longnameid() {
  longnameid_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbOptionItemPb::longnameid() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongNameID)
  return _internal_longnameid();
}
inline void DDbOptionItemPb::set_longnameid(const std::string& value) {
  _internal_set_longnameid(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongNameID)
}
inline std::string* DDbOptionItemPb::mutable_longnameid() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongNameID)
  return _internal_mutable_longnameid();
}
inline const std::string& DDbOptionItemPb::_internal_longnameid() const {
  return longnameid_.GetNoArena();
}
inline void DDbOptionItemPb::_internal_set_longnameid(const std::string& value) {
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbOptionItemPb::set_longnameid(std::string&& value) {
  
  longnameid_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongNameID)
}
inline void DDbOptionItemPb::set_longnameid(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongNameID)
}
inline void DDbOptionItemPb::set_longnameid(const char* value, size_t size) {
  
  longnameid_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongNameID)
}
inline std::string* DDbOptionItemPb::_internal_mutable_longnameid() {
  
  return longnameid_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbOptionItemPb::release_longnameid() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongNameID)
  
  return longnameid_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbOptionItemPb::set_allocated_longnameid(std::string* longnameid) {
  if (longnameid != nullptr) {
    
  } else {
    
  }
  longnameid_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), longnameid);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.LongNameID)
}

// string ShortName = 5;
inline void DDbOptionItemPb::clear_shortname() {
  shortname_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbOptionItemPb::shortname() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ShortName)
  return _internal_shortname();
}
inline void DDbOptionItemPb::set_shortname(const std::string& value) {
  _internal_set_shortname(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ShortName)
}
inline std::string* DDbOptionItemPb::mutable_shortname() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ShortName)
  return _internal_mutable_shortname();
}
inline const std::string& DDbOptionItemPb::_internal_shortname() const {
  return shortname_.GetNoArena();
}
inline void DDbOptionItemPb::_internal_set_shortname(const std::string& value) {
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbOptionItemPb::set_shortname(std::string&& value) {
  
  shortname_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ShortName)
}
inline void DDbOptionItemPb::set_shortname(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ShortName)
}
inline void DDbOptionItemPb::set_shortname(const char* value, size_t size) {
  
  shortname_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ShortName)
}
inline std::string* DDbOptionItemPb::_internal_mutable_shortname() {
  
  return shortname_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbOptionItemPb::release_shortname() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ShortName)
  
  return shortname_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbOptionItemPb::set_allocated_shortname(std::string* shortname) {
  if (shortname != nullptr) {
    
  } else {
    
  }
  shortname_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), shortname);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ShortName)
}

// string UniqueObjectIdentifier = 6;
inline void DDbOptionItemPb::clear_uniqueobjectidentifier() {
  uniqueobjectidentifier_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbOptionItemPb::uniqueobjectidentifier() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UniqueObjectIdentifier)
  return _internal_uniqueobjectidentifier();
}
inline void DDbOptionItemPb::set_uniqueobjectidentifier(const std::string& value) {
  _internal_set_uniqueobjectidentifier(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UniqueObjectIdentifier)
}
inline std::string* DDbOptionItemPb::mutable_uniqueobjectidentifier() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UniqueObjectIdentifier)
  return _internal_mutable_uniqueobjectidentifier();
}
inline const std::string& DDbOptionItemPb::_internal_uniqueobjectidentifier() const {
  return uniqueobjectidentifier_.GetNoArena();
}
inline void DDbOptionItemPb::_internal_set_uniqueobjectidentifier(const std::string& value) {
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbOptionItemPb::set_uniqueobjectidentifier(std::string&& value) {
  
  uniqueobjectidentifier_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UniqueObjectIdentifier)
}
inline void DDbOptionItemPb::set_uniqueobjectidentifier(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UniqueObjectIdentifier)
}
inline void DDbOptionItemPb::set_uniqueobjectidentifier(const char* value, size_t size) {
  
  uniqueobjectidentifier_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UniqueObjectIdentifier)
}
inline std::string* DDbOptionItemPb::_internal_mutable_uniqueobjectidentifier() {
  
  return uniqueobjectidentifier_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbOptionItemPb::release_uniqueobjectidentifier() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UniqueObjectIdentifier)
  
  return uniqueobjectidentifier_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbOptionItemPb::set_allocated_uniqueobjectidentifier(std::string* uniqueobjectidentifier) {
  if (uniqueobjectidentifier != nullptr) {
    
  } else {
    
  }
  uniqueobjectidentifier_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), uniqueobjectidentifier);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UniqueObjectIdentifier)
}

// int32 ObjectType = 7;
inline void DDbOptionItemPb::clear_objecttype() {
  objecttype_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbOptionItemPb::_internal_objecttype() const {
  return objecttype_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbOptionItemPb::objecttype() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ObjectType)
  return _internal_objecttype();
}
inline void DDbOptionItemPb::_internal_set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  objecttype_ = value;
}
inline void DDbOptionItemPb::set_objecttype(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_objecttype(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ObjectType)
}

// uint32 BitLength = 8;
inline void DDbOptionItemPb::clear_bitlength() {
  bitlength_ = 0u;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DDbOptionItemPb::_internal_bitlength() const {
  return bitlength_;
}
inline ::PROTOBUF_NAMESPACE_ID::uint32 DDbOptionItemPb::bitlength() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.BitLength)
  return _internal_bitlength();
}
inline void DDbOptionItemPb::_internal_set_bitlength(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  
  bitlength_ = value;
}
inline void DDbOptionItemPb::set_bitlength(::PROTOBUF_NAMESPACE_ID::uint32 value) {
  _internal_set_bitlength(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.BitLength)
}

// int32 BitPosition = 9;
inline void DDbOptionItemPb::clear_bitposition() {
  bitposition_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbOptionItemPb::_internal_bitposition() const {
  return bitposition_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbOptionItemPb::bitposition() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.BitPosition)
  return _internal_bitposition();
}
inline void DDbOptionItemPb::_internal_set_bitposition(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  bitposition_ = value;
}
inline void DDbOptionItemPb::set_bitposition(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_bitposition(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.BitPosition)
}

// int32 BytePosition = 21;
inline void DDbOptionItemPb::clear_byteposition() {
  byteposition_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbOptionItemPb::_internal_byteposition() const {
  return byteposition_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbOptionItemPb::byteposition() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.BytePosition)
  return _internal_byteposition();
}
inline void DDbOptionItemPb::_internal_set_byteposition(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  byteposition_ = value;
}
inline void DDbOptionItemPb::set_byteposition(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_byteposition(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.BytePosition)
}

// int32 DecimalPlaces = 10;
inline void DDbOptionItemPb::clear_decimalplaces() {
  decimalplaces_ = 0;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbOptionItemPb::_internal_decimalplaces() const {
  return decimalplaces_;
}
inline ::PROTOBUF_NAMESPACE_ID::int32 DDbOptionItemPb::decimalplaces() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DecimalPlaces)
  return _internal_decimalplaces();
}
inline void DDbOptionItemPb::_internal_set_decimalplaces(::PROTOBUF_NAMESPACE_ID::int32 value) {
  
  decimalplaces_ = value;
}
inline void DDbOptionItemPb::set_decimalplaces(::PROTOBUF_NAMESPACE_ID::int32 value) {
  _internal_set_decimalplaces(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DecimalPlaces)
}

// .OpenTestSystem.OtxDiagManager.Common.DIntervalPb Interval = 11;
inline bool DDbOptionItemPb::_internal_has_interval() const {
  return this != internal_default_instance() && interval_ != nullptr;
}
inline bool DDbOptionItemPb::has_interval() const {
  return _internal_has_interval();
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb& DDbOptionItemPb::_internal_interval() const {
  const ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb* p = interval_;
  return p != nullptr ? *p : *reinterpret_cast<const ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb*>(
      &::OpenTestSystem::OtxDiagManager::Common::_DIntervalPb_default_instance_);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb& DDbOptionItemPb::interval() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Interval)
  return _internal_interval();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb* DDbOptionItemPb::release_interval() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Interval)
  
  ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb* temp = interval_;
  interval_ = nullptr;
  return temp;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb* DDbOptionItemPb::_internal_mutable_interval() {
  
  if (interval_ == nullptr) {
    auto* p = CreateMaybeMessage<::OpenTestSystem::OtxDiagManager::Common::DIntervalPb>(GetArenaNoVirtual());
    interval_ = p;
  }
  return interval_;
}
inline ::OpenTestSystem::OtxDiagManager::Common::DIntervalPb* DDbOptionItemPb::mutable_interval() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Interval)
  return _internal_mutable_interval();
}
inline void DDbOptionItemPb::set_allocated_interval(::OpenTestSystem::OtxDiagManager::Common::DIntervalPb* interval) {
  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaNoVirtual();
  if (message_arena == nullptr) {
    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(interval_);
  }
  if (interval) {
    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena = nullptr;
    if (message_arena != submessage_arena) {
      interval = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
          message_arena, interval, submessage_arena);
    }
    
  } else {
    
  }
  interval_ = interval;
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Interval)
}

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

// string Semantic = 13;
inline void DDbOptionItemPb::clear_semantic() {
  semantic_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbOptionItemPb::semantic() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Semantic)
  return _internal_semantic();
}
inline void DDbOptionItemPb::set_semantic(const std::string& value) {
  _internal_set_semantic(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Semantic)
}
inline std::string* DDbOptionItemPb::mutable_semantic() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Semantic)
  return _internal_mutable_semantic();
}
inline const std::string& DDbOptionItemPb::_internal_semantic() const {
  return semantic_.GetNoArena();
}
inline void DDbOptionItemPb::_internal_set_semantic(const std::string& value) {
  
  semantic_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbOptionItemPb::set_semantic(std::string&& value) {
  
  semantic_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Semantic)
}
inline void DDbOptionItemPb::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.DDbOptionItemPb.Semantic)
}
inline void DDbOptionItemPb::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.DDbOptionItemPb.Semantic)
}
inline std::string* DDbOptionItemPb::_internal_mutable_semantic() {
  
  return semantic_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbOptionItemPb::release_semantic() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.Semantic)
  
  return semantic_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbOptionItemPb::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.DDbOptionItemPb.Semantic)
}

// string UnitAsString = 14;
inline void DDbOptionItemPb::clear_unitasstring() {
  unitasstring_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbOptionItemPb::unitasstring() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UnitAsString)
  return _internal_unitasstring();
}
inline void DDbOptionItemPb::set_unitasstring(const std::string& value) {
  _internal_set_unitasstring(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UnitAsString)
}
inline std::string* DDbOptionItemPb::mutable_unitasstring() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UnitAsString)
  return _internal_mutable_unitasstring();
}
inline const std::string& DDbOptionItemPb::_internal_unitasstring() const {
  return unitasstring_.GetNoArena();
}
inline void DDbOptionItemPb::_internal_set_unitasstring(const std::string& value) {
  
  unitasstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbOptionItemPb::set_unitasstring(std::string&& value) {
  
  unitasstring_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UnitAsString)
}
inline void DDbOptionItemPb::set_unitasstring(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  unitasstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UnitAsString)
}
inline void DDbOptionItemPb::set_unitasstring(const char* value, size_t size) {
  
  unitasstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UnitAsString)
}
inline std::string* DDbOptionItemPb::_internal_mutable_unitasstring() {
  
  return unitasstring_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbOptionItemPb::release_unitasstring() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UnitAsString)
  
  return unitasstring_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbOptionItemPb::set_allocated_unitasstring(std::string* unitasstring) {
  if (unitasstring != nullptr) {
    
  } else {
    
  }
  unitasstring_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), unitasstring);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.UnitAsString)
}

// string PhysicalDefaultValueAsString = 15;
inline void DDbOptionItemPb::clear_physicaldefaultvalueasstring() {
  physicaldefaultvalueasstring_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbOptionItemPb::physicaldefaultvalueasstring() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.PhysicalDefaultValueAsString)
  return _internal_physicaldefaultvalueasstring();
}
inline void DDbOptionItemPb::set_physicaldefaultvalueasstring(const std::string& value) {
  _internal_set_physicaldefaultvalueasstring(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.PhysicalDefaultValueAsString)
}
inline std::string* DDbOptionItemPb::mutable_physicaldefaultvalueasstring() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.PhysicalDefaultValueAsString)
  return _internal_mutable_physicaldefaultvalueasstring();
}
inline const std::string& DDbOptionItemPb::_internal_physicaldefaultvalueasstring() const {
  return physicaldefaultvalueasstring_.GetNoArena();
}
inline void DDbOptionItemPb::_internal_set_physicaldefaultvalueasstring(const std::string& value) {
  
  physicaldefaultvalueasstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbOptionItemPb::set_physicaldefaultvalueasstring(std::string&& value) {
  
  physicaldefaultvalueasstring_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.PhysicalDefaultValueAsString)
}
inline void DDbOptionItemPb::set_physicaldefaultvalueasstring(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  physicaldefaultvalueasstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.PhysicalDefaultValueAsString)
}
inline void DDbOptionItemPb::set_physicaldefaultvalueasstring(const char* value, size_t size) {
  
  physicaldefaultvalueasstring_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.PhysicalDefaultValueAsString)
}
inline std::string* DDbOptionItemPb::_internal_mutable_physicaldefaultvalueasstring() {
  
  return physicaldefaultvalueasstring_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbOptionItemPb::release_physicaldefaultvalueasstring() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.PhysicalDefaultValueAsString)
  
  return physicaldefaultvalueasstring_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbOptionItemPb::set_allocated_physicaldefaultvalueasstring(std::string* physicaldefaultvalueasstring) {
  if (physicaldefaultvalueasstring != nullptr) {
    
  } else {
    
  }
  physicaldefaultvalueasstring_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), physicaldefaultvalueasstring);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.PhysicalDefaultValueAsString)
}

// string ReadAudienceState = 16;
inline void DDbOptionItemPb::clear_readaudiencestate() {
  readaudiencestate_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbOptionItemPb::readaudiencestate() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ReadAudienceState)
  return _internal_readaudiencestate();
}
inline void DDbOptionItemPb::set_readaudiencestate(const std::string& value) {
  _internal_set_readaudiencestate(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ReadAudienceState)
}
inline std::string* DDbOptionItemPb::mutable_readaudiencestate() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ReadAudienceState)
  return _internal_mutable_readaudiencestate();
}
inline const std::string& DDbOptionItemPb::_internal_readaudiencestate() const {
  return readaudiencestate_.GetNoArena();
}
inline void DDbOptionItemPb::_internal_set_readaudiencestate(const std::string& value) {
  
  readaudiencestate_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbOptionItemPb::set_readaudiencestate(std::string&& value) {
  
  readaudiencestate_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ReadAudienceState)
}
inline void DDbOptionItemPb::set_readaudiencestate(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  readaudiencestate_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ReadAudienceState)
}
inline void DDbOptionItemPb::set_readaudiencestate(const char* value, size_t size) {
  
  readaudiencestate_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ReadAudienceState)
}
inline std::string* DDbOptionItemPb::_internal_mutable_readaudiencestate() {
  
  return readaudiencestate_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbOptionItemPb::release_readaudiencestate() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ReadAudienceState)
  
  return readaudiencestate_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbOptionItemPb::set_allocated_readaudiencestate(std::string* readaudiencestate) {
  if (readaudiencestate != nullptr) {
    
  } else {
    
  }
  readaudiencestate_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), readaudiencestate);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.ReadAudienceState)
}

// string WriteAudienceState = 17;
inline void DDbOptionItemPb::clear_writeaudiencestate() {
  writeaudiencestate_.ClearToEmptyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline const std::string& DDbOptionItemPb::writeaudiencestate() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.WriteAudienceState)
  return _internal_writeaudiencestate();
}
inline void DDbOptionItemPb::set_writeaudiencestate(const std::string& value) {
  _internal_set_writeaudiencestate(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.WriteAudienceState)
}
inline std::string* DDbOptionItemPb::mutable_writeaudiencestate() {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.WriteAudienceState)
  return _internal_mutable_writeaudiencestate();
}
inline const std::string& DDbOptionItemPb::_internal_writeaudiencestate() const {
  return writeaudiencestate_.GetNoArena();
}
inline void DDbOptionItemPb::_internal_set_writeaudiencestate(const std::string& value) {
  
  writeaudiencestate_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value);
}
inline void DDbOptionItemPb::set_writeaudiencestate(std::string&& value) {
  
  writeaudiencestate_.SetNoArena(
    &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::move(value));
  // @@protoc_insertion_point(field_set_rvalue:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.WriteAudienceState)
}
inline void DDbOptionItemPb::set_writeaudiencestate(const char* value) {
  GOOGLE_DCHECK(value != nullptr);
  
  writeaudiencestate_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ::std::string(value));
  // @@protoc_insertion_point(field_set_char:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.WriteAudienceState)
}
inline void DDbOptionItemPb::set_writeaudiencestate(const char* value, size_t size) {
  
  writeaudiencestate_.SetNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(),
      ::std::string(reinterpret_cast<const char*>(value), size));
  // @@protoc_insertion_point(field_set_pointer:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.WriteAudienceState)
}
inline std::string* DDbOptionItemPb::_internal_mutable_writeaudiencestate() {
  
  return writeaudiencestate_.MutableNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline std::string* DDbOptionItemPb::release_writeaudiencestate() {
  // @@protoc_insertion_point(field_release:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.WriteAudienceState)
  
  return writeaudiencestate_.ReleaseNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
}
inline void DDbOptionItemPb::set_allocated_writeaudiencestate(std::string* writeaudiencestate) {
  if (writeaudiencestate != nullptr) {
    
  } else {
    
  }
  writeaudiencestate_.SetAllocatedNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), writeaudiencestate);
  // @@protoc_insertion_point(field_set_allocated:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.WriteAudienceState)
}

// repeated .OpenTestSystem.OtxDiagManager.Common.DDbItemValuePb DbItemValues = 18;
inline int DDbOptionItemPb::_internal_dbitemvalues_size() const {
  return dbitemvalues_.size();
}
inline int DDbOptionItemPb::dbitemvalues_size() const {
  return _internal_dbitemvalues_size();
}
inline void DDbOptionItemPb::clear_dbitemvalues() {
  dbitemvalues_.Clear();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb* DDbOptionItemPb::mutable_dbitemvalues(int index) {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DbItemValues)
  return dbitemvalues_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb >*
DDbOptionItemPb::mutable_dbitemvalues() {
  // @@protoc_insertion_point(field_mutable_list:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DbItemValues)
  return &dbitemvalues_;
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb& DDbOptionItemPb::_internal_dbitemvalues(int index) const {
  return dbitemvalues_.Get(index);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb& DDbOptionItemPb::dbitemvalues(int index) const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DbItemValues)
  return _internal_dbitemvalues(index);
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb* DDbOptionItemPb::_internal_add_dbitemvalues() {
  return dbitemvalues_.Add();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb* DDbOptionItemPb::add_dbitemvalues() {
  // @@protoc_insertion_point(field_add:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DbItemValues)
  return _internal_add_dbitemvalues();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OpenTestSystem::OtxDiagManager::Common::DDbItemValuePb >&
DDbOptionItemPb::dbitemvalues() const {
  // @@protoc_insertion_point(field_list:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.DbItemValues)
  return dbitemvalues_;
}

// repeated .OpenTestSystem.OtxDiagManager.Common.DTextTableElementPb TextTableElements = 19;
inline int DDbOptionItemPb::_internal_texttableelements_size() const {
  return texttableelements_.size();
}
inline int DDbOptionItemPb::texttableelements_size() const {
  return _internal_texttableelements_size();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb* DDbOptionItemPb::mutable_texttableelements(int index) {
  // @@protoc_insertion_point(field_mutable:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.TextTableElements)
  return texttableelements_.Mutable(index);
}
inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb >*
DDbOptionItemPb::mutable_texttableelements() {
  // @@protoc_insertion_point(field_mutable_list:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.TextTableElements)
  return &texttableelements_;
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb& DDbOptionItemPb::_internal_texttableelements(int index) const {
  return texttableelements_.Get(index);
}
inline const ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb& DDbOptionItemPb::texttableelements(int index) const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.TextTableElements)
  return _internal_texttableelements(index);
}
inline ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb* DDbOptionItemPb::_internal_add_texttableelements() {
  return texttableelements_.Add();
}
inline ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb* DDbOptionItemPb::add_texttableelements() {
  // @@protoc_insertion_point(field_add:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.TextTableElements)
  return _internal_add_texttableelements();
}
inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::OpenTestSystem::OtxDiagManager::Common::DTextTableElementPb >&
DDbOptionItemPb::texttableelements() const {
  // @@protoc_insertion_point(field_list:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.TextTableElements)
  return texttableelements_;
}

// bool IsComplex = 20;
inline void DDbOptionItemPb::clear_iscomplex() {
  iscomplex_ = false;
}
inline bool DDbOptionItemPb::_internal_iscomplex() const {
  return iscomplex_;
}
inline bool DDbOptionItemPb::iscomplex() const {
  // @@protoc_insertion_point(field_get:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.IsComplex)
  return _internal_iscomplex();
}
inline void DDbOptionItemPb::_internal_set_iscomplex(bool value) {
  
  iscomplex_ = value;
}
inline void DDbOptionItemPb::set_iscomplex(bool value) {
  _internal_set_iscomplex(value);
  // @@protoc_insertion_point(field_set:OpenTestSystem.OtxDiagManager.Common.DDbOptionItemPb.IsComplex)
}

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