field_options.pb.h

Go to the documentation of this file.

// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: global_extensions/field_options.proto
 
#ifndef PROTOBUF_global_5fextensions_2ffield_5foptions_2eproto__INCLUDED
#define PROTOBUF_global_5fextensions_2ffield_5foptions_2eproto__INCLUDED
 
#include <string>
 
#include <google/protobuf/stubs/common.h>
 
#if GOOGLE_PROTOBUF_VERSION < 2006000
#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 2006001 < GOOGLE_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/generated_message_util.h>
#include <google/protobuf/message.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_enum_reflection.h>
#include <google/protobuf/unknown_field_set.h>
#include "google/protobuf/descriptor.pb.h"
#include "global_extensions/range.pb.h"
#include "Define.h" // for TC_PROTO_API
// @@protoc_insertion_point(includes)
 
namespace bgs {
namespace protocol {
 
// Internal implementation detail -- do not call these.
void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
class BGSFieldOptions;
class FieldRestriction;
class RepeatedFieldRestriction;
class SignedFieldRestriction;
class UnsignedFieldRestriction;
class FloatFieldRestriction;
class StringFieldRestriction;
class EntityIdRestriction;
class MessageFieldRestriction;
class SDKFieldOptions;
 
enum EntityIdRestriction_Kind {
  EntityIdRestriction_Kind_ANY = 0,
  EntityIdRestriction_Kind_ACCOUNT = 1,
  EntityIdRestriction_Kind_GAME_ACCOUNT = 2,
  EntityIdRestriction_Kind_ACCOUNT_OR_GAME_ACCOUNT = 3,
  EntityIdRestriction_Kind_SERVICE = 4,
  EntityIdRestriction_Kind_CHANNEL = 5
};
TC_PROTO_API bool EntityIdRestriction_Kind_IsValid(int value);
const EntityIdRestriction_Kind EntityIdRestriction_Kind_Kind_MIN = EntityIdRestriction_Kind_ANY;
const EntityIdRestriction_Kind EntityIdRestriction_Kind_Kind_MAX = EntityIdRestriction_Kind_CHANNEL;
const int EntityIdRestriction_Kind_Kind_ARRAYSIZE = EntityIdRestriction_Kind_Kind_MAX + 1;
 
TC_PROTO_API const ::google::protobuf::EnumDescriptor* EntityIdRestriction_Kind_descriptor();
inline const ::std::string& EntityIdRestriction_Kind_Name(EntityIdRestriction_Kind value) {
  return ::google::protobuf::internal::NameOfEnum(
    EntityIdRestriction_Kind_descriptor(), value);
}
inline bool EntityIdRestriction_Kind_Parse(
    const ::std::string& name, EntityIdRestriction_Kind* value) {
  return ::google::protobuf::internal::ParseNamedEnum<EntityIdRestriction_Kind>(
    EntityIdRestriction_Kind_descriptor(), name, value);
}
enum LogOption {
  HIDDEN = 1,
  HEX = 2
};
TC_PROTO_API bool LogOption_IsValid(int value);
const LogOption LogOption_MIN = HIDDEN;
const LogOption LogOption_MAX = HEX;
const int LogOption_ARRAYSIZE = LogOption_MAX + 1;
 
TC_PROTO_API const ::google::protobuf::EnumDescriptor* LogOption_descriptor();
inline const ::std::string& LogOption_Name(LogOption value) {
  return ::google::protobuf::internal::NameOfEnum(
    LogOption_descriptor(), value);
}
inline bool LogOption_Parse(
    const ::std::string& name, LogOption* value) {
  return ::google::protobuf::internal::ParseNamedEnum<LogOption>(
    LogOption_descriptor(), name, value);
}
// ===================================================================
 
class TC_PROTO_API BGSFieldOptions : public ::google::protobuf::Message {
 public:
  BGSFieldOptions();
  virtual ~BGSFieldOptions();
 
  BGSFieldOptions(const BGSFieldOptions& from);
 
  inline BGSFieldOptions& operator=(const BGSFieldOptions& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const BGSFieldOptions& default_instance();
 
  void Swap(BGSFieldOptions* other);
 
  // implements Message ----------------------------------------------
 
  BGSFieldOptions* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.LogOption log = 1;
  inline bool has_log() const;
  inline void clear_log();
  static const int kLogFieldNumber = 1;
  inline ::bgs::protocol::LogOption log() const;
  inline void set_log(::bgs::protocol::LogOption value);
 
  // optional bool shard_key = 2;
  inline bool has_shard_key() const;
  inline void clear_shard_key();
  static const int kShardKeyFieldNumber = 2;
  inline bool shard_key() const;
  inline void set_shard_key(bool value);
 
  // optional bool fanout_key = 3;
  inline bool has_fanout_key() const;
  inline void clear_fanout_key();
  static const int kFanoutKeyFieldNumber = 3;
  inline bool fanout_key() const;
  inline void set_fanout_key(bool value);
 
  // optional bool client_instance_key = 4;
  inline bool has_client_instance_key() const;
  inline void clear_client_instance_key();
  static const int kClientInstanceKeyFieldNumber = 4;
  inline bool client_instance_key() const;
  inline void set_client_instance_key(bool value);
 
  // optional string realized_enum = 5;
  inline bool has_realized_enum() const;
  inline void clear_realized_enum();
  static const int kRealizedEnumFieldNumber = 5;
  inline const ::std::string& realized_enum() const;
  inline void set_realized_enum(const ::std::string& value);
  inline void set_realized_enum(const char* value);
  inline void set_realized_enum(const char* value, size_t size);
  inline ::std::string* mutable_realized_enum();
  inline ::std::string* release_realized_enum();
  inline void set_allocated_realized_enum(::std::string* realized_enum);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.BGSFieldOptions)
 private:
  inline void set_has_log();
  inline void clear_has_log();
  inline void set_has_shard_key();
  inline void clear_has_shard_key();
  inline void set_has_fanout_key();
  inline void clear_has_fanout_key();
  inline void set_has_client_instance_key();
  inline void clear_has_client_instance_key();
  inline void set_has_realized_enum();
  inline void clear_has_realized_enum();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  int log_;
  bool shard_key_;
  bool fanout_key_;
  bool client_instance_key_;
  ::std::string* realized_enum_;
  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
  void InitAsDefaultInstance();
  static BGSFieldOptions* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API FieldRestriction : public ::google::protobuf::Message {
 public:
  FieldRestriction();
  virtual ~FieldRestriction();
 
  FieldRestriction(const FieldRestriction& from);
 
  inline FieldRestriction& operator=(const FieldRestriction& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const FieldRestriction& default_instance();
 
  enum TypeCase {
    kSigned = 1,
    kUnsigned = 2,
    kFloat = 3,
    kString = 4,
    kRepeated = 5,
    kMessage = 6,
    kEntityId = 7,
    kBytes = 8,
    TYPE_NOT_SET = 0,
  };
 
  void Swap(FieldRestriction* other);
 
  // implements Message ----------------------------------------------
 
  FieldRestriction* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.SignedFieldRestriction signed = 1;
  inline bool has_signed_() const;
  inline void clear_signed_();
  static const int kSignedFieldNumber = 1;
  inline const ::bgs::protocol::SignedFieldRestriction& signed_() const;
  inline ::bgs::protocol::SignedFieldRestriction* mutable_signed_();
  inline ::bgs::protocol::SignedFieldRestriction* release_signed_();
  inline void set_allocated_signed_(::bgs::protocol::SignedFieldRestriction* signed_);
 
  // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 2;
  inline bool has_unsigned_() const;
  inline void clear_unsigned_();
  static const int kUnsignedFieldNumber = 2;
  inline const ::bgs::protocol::UnsignedFieldRestriction& unsigned_() const;
  inline ::bgs::protocol::UnsignedFieldRestriction* mutable_unsigned_();
  inline ::bgs::protocol::UnsignedFieldRestriction* release_unsigned_();
  inline void set_allocated_unsigned_(::bgs::protocol::UnsignedFieldRestriction* unsigned_);
 
  // optional .bgs.protocol.FloatFieldRestriction float = 3;
  inline bool has_float_() const;
  inline void clear_float_();
  static const int kFloatFieldNumber = 3;
  inline const ::bgs::protocol::FloatFieldRestriction& float_() const;
  inline ::bgs::protocol::FloatFieldRestriction* mutable_float_();
  inline ::bgs::protocol::FloatFieldRestriction* release_float_();
  inline void set_allocated_float_(::bgs::protocol::FloatFieldRestriction* float_);
 
  // optional .bgs.protocol.StringFieldRestriction string = 4;
  inline bool has_string() const;
  inline void clear_string();
  static const int kStringFieldNumber = 4;
  inline const ::bgs::protocol::StringFieldRestriction& string() const;
  inline ::bgs::protocol::StringFieldRestriction* mutable_string();
  inline ::bgs::protocol::StringFieldRestriction* release_string();
  inline void set_allocated_string(::bgs::protocol::StringFieldRestriction* string);
 
  // optional .bgs.protocol.RepeatedFieldRestriction repeated = 5;
  inline bool has_repeated() const;
  inline void clear_repeated();
  static const int kRepeatedFieldNumber = 5;
  inline const ::bgs::protocol::RepeatedFieldRestriction& repeated() const;
  inline ::bgs::protocol::RepeatedFieldRestriction* mutable_repeated();
  inline ::bgs::protocol::RepeatedFieldRestriction* release_repeated();
  inline void set_allocated_repeated(::bgs::protocol::RepeatedFieldRestriction* repeated);
 
  // optional .bgs.protocol.MessageFieldRestriction message = 6;
  inline bool has_message() const;
  inline void clear_message();
  static const int kMessageFieldNumber = 6;
  inline const ::bgs::protocol::MessageFieldRestriction& message() const;
  inline ::bgs::protocol::MessageFieldRestriction* mutable_message();
  inline ::bgs::protocol::MessageFieldRestriction* release_message();
  inline void set_allocated_message(::bgs::protocol::MessageFieldRestriction* message);
 
  // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
  inline bool has_entity_id() const;
  inline void clear_entity_id();
  static const int kEntityIdFieldNumber = 7;
  inline const ::bgs::protocol::EntityIdRestriction& entity_id() const;
  inline ::bgs::protocol::EntityIdRestriction* mutable_entity_id();
  inline ::bgs::protocol::EntityIdRestriction* release_entity_id();
  inline void set_allocated_entity_id(::bgs::protocol::EntityIdRestriction* entity_id);
 
  // optional .bgs.protocol.StringFieldRestriction bytes = 8;
  inline bool has_bytes() const;
  inline void clear_bytes();
  static const int kBytesFieldNumber = 8;
  inline const ::bgs::protocol::StringFieldRestriction& bytes() const;
  inline ::bgs::protocol::StringFieldRestriction* mutable_bytes();
  inline ::bgs::protocol::StringFieldRestriction* release_bytes();
  inline void set_allocated_bytes(::bgs::protocol::StringFieldRestriction* bytes);
 
  inline TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:bgs.protocol.FieldRestriction)
 private:
  inline void set_has_signed_();
  inline void set_has_unsigned_();
  inline void set_has_float_();
  inline void set_has_string();
  inline void set_has_repeated();
  inline void set_has_message();
  inline void set_has_entity_id();
  inline void set_has_bytes();
 
  inline bool has_type();
  void clear_type();
  inline void clear_has_type();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  union TypeUnion {
    ::bgs::protocol::SignedFieldRestriction* signed__;
    ::bgs::protocol::UnsignedFieldRestriction* unsigned__;
    ::bgs::protocol::FloatFieldRestriction* float__;
    ::bgs::protocol::StringFieldRestriction* string_;
    ::bgs::protocol::RepeatedFieldRestriction* repeated_;
    ::bgs::protocol::MessageFieldRestriction* message_;
    ::bgs::protocol::EntityIdRestriction* entity_id_;
    ::bgs::protocol::StringFieldRestriction* bytes_;
  } type_;
  ::google::protobuf::uint32 _oneof_case_[1];
 
  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
  void InitAsDefaultInstance();
  static FieldRestriction* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API RepeatedFieldRestriction : public ::google::protobuf::Message {
 public:
  RepeatedFieldRestriction();
  virtual ~RepeatedFieldRestriction();
 
  RepeatedFieldRestriction(const RepeatedFieldRestriction& from);
 
  inline RepeatedFieldRestriction& operator=(const RepeatedFieldRestriction& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const RepeatedFieldRestriction& default_instance();
 
  enum TypeCase {
    kSigned = 3,
    kUnsigned = 4,
    kFloat = 5,
    kString = 6,
    kEntityId = 7,
    kBytes = 8,
    TYPE_NOT_SET = 0,
  };
 
  void Swap(RepeatedFieldRestriction* other);
 
  // implements Message ----------------------------------------------
 
  RepeatedFieldRestriction* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.UnsignedIntRange size = 1;
  inline bool has_size() const;
  inline void clear_size();
  static const int kSizeFieldNumber = 1;
  inline const ::bgs::protocol::UnsignedIntRange& size() const;
  inline ::bgs::protocol::UnsignedIntRange* mutable_size();
  inline ::bgs::protocol::UnsignedIntRange* release_size();
  inline void set_allocated_size(::bgs::protocol::UnsignedIntRange* size);
 
  // optional bool unique = 2;
  inline bool has_unique() const;
  inline void clear_unique();
  static const int kUniqueFieldNumber = 2;
  inline bool unique() const;
  inline void set_unique(bool value);
 
  // optional .bgs.protocol.SignedFieldRestriction signed = 3;
  inline bool has_signed_() const;
  inline void clear_signed_();
  static const int kSignedFieldNumber = 3;
  inline const ::bgs::protocol::SignedFieldRestriction& signed_() const;
  inline ::bgs::protocol::SignedFieldRestriction* mutable_signed_();
  inline ::bgs::protocol::SignedFieldRestriction* release_signed_();
  inline void set_allocated_signed_(::bgs::protocol::SignedFieldRestriction* signed_);
 
  // optional .bgs.protocol.UnsignedFieldRestriction unsigned = 4;
  inline bool has_unsigned_() const;
  inline void clear_unsigned_();
  static const int kUnsignedFieldNumber = 4;
  inline const ::bgs::protocol::UnsignedFieldRestriction& unsigned_() const;
  inline ::bgs::protocol::UnsignedFieldRestriction* mutable_unsigned_();
  inline ::bgs::protocol::UnsignedFieldRestriction* release_unsigned_();
  inline void set_allocated_unsigned_(::bgs::protocol::UnsignedFieldRestriction* unsigned_);
 
  // optional .bgs.protocol.FloatFieldRestriction float = 5;
  inline bool has_float_() const;
  inline void clear_float_();
  static const int kFloatFieldNumber = 5;
  inline const ::bgs::protocol::FloatFieldRestriction& float_() const;
  inline ::bgs::protocol::FloatFieldRestriction* mutable_float_();
  inline ::bgs::protocol::FloatFieldRestriction* release_float_();
  inline void set_allocated_float_(::bgs::protocol::FloatFieldRestriction* float_);
 
  // optional .bgs.protocol.StringFieldRestriction string = 6;
  inline bool has_string() const;
  inline void clear_string();
  static const int kStringFieldNumber = 6;
  inline const ::bgs::protocol::StringFieldRestriction& string() const;
  inline ::bgs::protocol::StringFieldRestriction* mutable_string();
  inline ::bgs::protocol::StringFieldRestriction* release_string();
  inline void set_allocated_string(::bgs::protocol::StringFieldRestriction* string);
 
  // optional .bgs.protocol.EntityIdRestriction entity_id = 7;
  inline bool has_entity_id() const;
  inline void clear_entity_id();
  static const int kEntityIdFieldNumber = 7;
  inline const ::bgs::protocol::EntityIdRestriction& entity_id() const;
  inline ::bgs::protocol::EntityIdRestriction* mutable_entity_id();
  inline ::bgs::protocol::EntityIdRestriction* release_entity_id();
  inline void set_allocated_entity_id(::bgs::protocol::EntityIdRestriction* entity_id);
 
  // optional .bgs.protocol.StringFieldRestriction bytes = 8;
  inline bool has_bytes() const;
  inline void clear_bytes();
  static const int kBytesFieldNumber = 8;
  inline const ::bgs::protocol::StringFieldRestriction& bytes() const;
  inline ::bgs::protocol::StringFieldRestriction* mutable_bytes();
  inline ::bgs::protocol::StringFieldRestriction* release_bytes();
  inline void set_allocated_bytes(::bgs::protocol::StringFieldRestriction* bytes);
 
  inline TypeCase type_case() const;
  // @@protoc_insertion_point(class_scope:bgs.protocol.RepeatedFieldRestriction)
 private:
  inline void set_has_size();
  inline void clear_has_size();
  inline void set_has_unique();
  inline void clear_has_unique();
  inline void set_has_signed_();
  inline void set_has_unsigned_();
  inline void set_has_float_();
  inline void set_has_string();
  inline void set_has_entity_id();
  inline void set_has_bytes();
 
  inline bool has_type();
  void clear_type();
  inline void clear_has_type();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::UnsignedIntRange* size_;
  bool unique_;
  union TypeUnion {
    ::bgs::protocol::SignedFieldRestriction* signed__;
    ::bgs::protocol::UnsignedFieldRestriction* unsigned__;
    ::bgs::protocol::FloatFieldRestriction* float__;
    ::bgs::protocol::StringFieldRestriction* string_;
    ::bgs::protocol::EntityIdRestriction* entity_id_;
    ::bgs::protocol::StringFieldRestriction* bytes_;
  } type_;
  ::google::protobuf::uint32 _oneof_case_[1];
 
  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
  void InitAsDefaultInstance();
  static RepeatedFieldRestriction* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API SignedFieldRestriction : public ::google::protobuf::Message {
 public:
  SignedFieldRestriction();
  virtual ~SignedFieldRestriction();
 
  SignedFieldRestriction(const SignedFieldRestriction& from);
 
  inline SignedFieldRestriction& operator=(const SignedFieldRestriction& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const SignedFieldRestriction& default_instance();
 
  void Swap(SignedFieldRestriction* other);
 
  // implements Message ----------------------------------------------
 
  SignedFieldRestriction* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.SignedIntRange limits = 1;
  inline bool has_limits() const;
  inline void clear_limits();
  static const int kLimitsFieldNumber = 1;
  inline const ::bgs::protocol::SignedIntRange& limits() const;
  inline ::bgs::protocol::SignedIntRange* mutable_limits();
  inline ::bgs::protocol::SignedIntRange* release_limits();
  inline void set_allocated_limits(::bgs::protocol::SignedIntRange* limits);
 
  // repeated sint64 exclude = 2;
  inline int exclude_size() const;
  inline void clear_exclude();
  static const int kExcludeFieldNumber = 2;
  inline ::google::protobuf::int64 exclude(int index) const;
  inline void set_exclude(int index, ::google::protobuf::int64 value);
  inline void add_exclude(::google::protobuf::int64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
      exclude() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
      mutable_exclude();
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.SignedFieldRestriction)
 private:
  inline void set_has_limits();
  inline void clear_has_limits();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::SignedIntRange* limits_;
  ::google::protobuf::RepeatedField< ::google::protobuf::int64 > exclude_;
  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
  void InitAsDefaultInstance();
  static SignedFieldRestriction* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API UnsignedFieldRestriction : public ::google::protobuf::Message {
 public:
  UnsignedFieldRestriction();
  virtual ~UnsignedFieldRestriction();
 
  UnsignedFieldRestriction(const UnsignedFieldRestriction& from);
 
  inline UnsignedFieldRestriction& operator=(const UnsignedFieldRestriction& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const UnsignedFieldRestriction& default_instance();
 
  void Swap(UnsignedFieldRestriction* other);
 
  // implements Message ----------------------------------------------
 
  UnsignedFieldRestriction* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.UnsignedIntRange limits = 1;
  inline bool has_limits() const;
  inline void clear_limits();
  static const int kLimitsFieldNumber = 1;
  inline const ::bgs::protocol::UnsignedIntRange& limits() const;
  inline ::bgs::protocol::UnsignedIntRange* mutable_limits();
  inline ::bgs::protocol::UnsignedIntRange* release_limits();
  inline void set_allocated_limits(::bgs::protocol::UnsignedIntRange* limits);
 
  // repeated uint64 exclude = 2;
  inline int exclude_size() const;
  inline void clear_exclude();
  static const int kExcludeFieldNumber = 2;
  inline ::google::protobuf::uint64 exclude(int index) const;
  inline void set_exclude(int index, ::google::protobuf::uint64 value);
  inline void add_exclude(::google::protobuf::uint64 value);
  inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
      exclude() const;
  inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
      mutable_exclude();
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.UnsignedFieldRestriction)
 private:
  inline void set_has_limits();
  inline void clear_has_limits();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::UnsignedIntRange* limits_;
  ::google::protobuf::RepeatedField< ::google::protobuf::uint64 > exclude_;
  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
  void InitAsDefaultInstance();
  static UnsignedFieldRestriction* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API FloatFieldRestriction : public ::google::protobuf::Message {
 public:
  FloatFieldRestriction();
  virtual ~FloatFieldRestriction();
 
  FloatFieldRestriction(const FloatFieldRestriction& from);
 
  inline FloatFieldRestriction& operator=(const FloatFieldRestriction& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const FloatFieldRestriction& default_instance();
 
  void Swap(FloatFieldRestriction* other);
 
  // implements Message ----------------------------------------------
 
  FloatFieldRestriction* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.FloatRange limits = 1;
  inline bool has_limits() const;
  inline void clear_limits();
  static const int kLimitsFieldNumber = 1;
  inline const ::bgs::protocol::FloatRange& limits() const;
  inline ::bgs::protocol::FloatRange* mutable_limits();
  inline ::bgs::protocol::FloatRange* release_limits();
  inline void set_allocated_limits(::bgs::protocol::FloatRange* limits);
 
  // repeated float exclude = 2;
  inline int exclude_size() const;
  inline void clear_exclude();
  static const int kExcludeFieldNumber = 2;
  inline float exclude(int index) const;
  inline void set_exclude(int index, float value);
  inline void add_exclude(float value);
  inline const ::google::protobuf::RepeatedField< float >&
      exclude() const;
  inline ::google::protobuf::RepeatedField< float >*
      mutable_exclude();
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.FloatFieldRestriction)
 private:
  inline void set_has_limits();
  inline void clear_has_limits();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::FloatRange* limits_;
  ::google::protobuf::RepeatedField< float > exclude_;
  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
  void InitAsDefaultInstance();
  static FloatFieldRestriction* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API StringFieldRestriction : public ::google::protobuf::Message {
 public:
  StringFieldRestriction();
  virtual ~StringFieldRestriction();
 
  StringFieldRestriction(const StringFieldRestriction& from);
 
  inline StringFieldRestriction& operator=(const StringFieldRestriction& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const StringFieldRestriction& default_instance();
 
  void Swap(StringFieldRestriction* other);
 
  // implements Message ----------------------------------------------
 
  StringFieldRestriction* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional .bgs.protocol.UnsignedIntRange size = 1;
  inline bool has_size() const;
  inline void clear_size();
  static const int kSizeFieldNumber = 1;
  inline const ::bgs::protocol::UnsignedIntRange& size() const;
  inline ::bgs::protocol::UnsignedIntRange* mutable_size();
  inline ::bgs::protocol::UnsignedIntRange* release_size();
  inline void set_allocated_size(::bgs::protocol::UnsignedIntRange* size);
 
  // repeated string exclude = 2;
  inline int exclude_size() const;
  inline void clear_exclude();
  static const int kExcludeFieldNumber = 2;
  inline const ::std::string& exclude(int index) const;
  inline ::std::string* mutable_exclude(int index);
  inline void set_exclude(int index, const ::std::string& value);
  inline void set_exclude(int index, const char* value);
  inline void set_exclude(int index, const char* value, size_t size);
  inline ::std::string* add_exclude();
  inline void add_exclude(const ::std::string& value);
  inline void add_exclude(const char* value);
  inline void add_exclude(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& exclude() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_exclude();
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.StringFieldRestriction)
 private:
  inline void set_has_size();
  inline void clear_has_size();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  ::bgs::protocol::UnsignedIntRange* size_;
  ::google::protobuf::RepeatedPtrField< ::std::string> exclude_;
  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
  void InitAsDefaultInstance();
  static StringFieldRestriction* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API EntityIdRestriction : public ::google::protobuf::Message {
 public:
  EntityIdRestriction();
  virtual ~EntityIdRestriction();
 
  EntityIdRestriction(const EntityIdRestriction& from);
 
  inline EntityIdRestriction& operator=(const EntityIdRestriction& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const EntityIdRestriction& default_instance();
 
  void Swap(EntityIdRestriction* other);
 
  // implements Message ----------------------------------------------
 
  EntityIdRestriction* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  typedef EntityIdRestriction_Kind Kind;
  static const Kind ANY = EntityIdRestriction_Kind_ANY;
  static const Kind ACCOUNT = EntityIdRestriction_Kind_ACCOUNT;
  static const Kind GAME_ACCOUNT = EntityIdRestriction_Kind_GAME_ACCOUNT;
  static const Kind ACCOUNT_OR_GAME_ACCOUNT = EntityIdRestriction_Kind_ACCOUNT_OR_GAME_ACCOUNT;
  static const Kind SERVICE = EntityIdRestriction_Kind_SERVICE;
  static const Kind CHANNEL = EntityIdRestriction_Kind_CHANNEL;
  static inline bool Kind_IsValid(int value) {
    return EntityIdRestriction_Kind_IsValid(value);
  }
  static const Kind Kind_MIN =
    EntityIdRestriction_Kind_Kind_MIN;
  static const Kind Kind_MAX =
    EntityIdRestriction_Kind_Kind_MAX;
  static const int Kind_ARRAYSIZE =
    EntityIdRestriction_Kind_Kind_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Kind_descriptor() {
    return EntityIdRestriction_Kind_descriptor();
  }
  static inline const ::std::string& Kind_Name(Kind value) {
    return EntityIdRestriction_Kind_Name(value);
  }
  static inline bool Kind_Parse(const ::std::string& name,
      Kind* value) {
    return EntityIdRestriction_Kind_Parse(name, value);
  }
 
  // accessors -------------------------------------------------------
 
  // optional bool needed = 1;
  inline bool has_needed() const;
  inline void clear_needed();
  static const int kNeededFieldNumber = 1;
  inline bool needed() const;
  inline void set_needed(bool value);
 
  // optional .bgs.protocol.EntityIdRestriction.Kind kind = 2;
  inline bool has_kind() const;
  inline void clear_kind();
  static const int kKindFieldNumber = 2;
  inline ::bgs::protocol::EntityIdRestriction_Kind kind() const;
  inline void set_kind(::bgs::protocol::EntityIdRestriction_Kind value);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.EntityIdRestriction)
 private:
  inline void set_has_needed();
  inline void clear_has_needed();
  inline void set_has_kind();
  inline void clear_has_kind();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  bool needed_;
  int kind_;
  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
  void InitAsDefaultInstance();
  static EntityIdRestriction* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API MessageFieldRestriction : public ::google::protobuf::Message {
 public:
  MessageFieldRestriction();
  virtual ~MessageFieldRestriction();
 
  MessageFieldRestriction(const MessageFieldRestriction& from);
 
  inline MessageFieldRestriction& operator=(const MessageFieldRestriction& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const MessageFieldRestriction& default_instance();
 
  void Swap(MessageFieldRestriction* other);
 
  // implements Message ----------------------------------------------
 
  MessageFieldRestriction* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional bool needed = 1;
  inline bool has_needed() const;
  inline void clear_needed();
  static const int kNeededFieldNumber = 1;
  inline bool needed() const;
  inline void set_needed(bool value);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.MessageFieldRestriction)
 private:
  inline void set_has_needed();
  inline void clear_has_needed();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  bool needed_;
  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
  void InitAsDefaultInstance();
  static MessageFieldRestriction* default_instance_;
};
// -------------------------------------------------------------------
 
class TC_PROTO_API SDKFieldOptions : public ::google::protobuf::Message {
 public:
  SDKFieldOptions();
  virtual ~SDKFieldOptions();
 
  SDKFieldOptions(const SDKFieldOptions& from);
 
  inline SDKFieldOptions& operator=(const SDKFieldOptions& from) {
    CopyFrom(from);
    return *this;
  }
 
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
 
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
 
  static const ::google::protobuf::Descriptor* descriptor();
  static const SDKFieldOptions& default_instance();
 
  void Swap(SDKFieldOptions* other);
 
  // implements Message ----------------------------------------------
 
  SDKFieldOptions* New() const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  ::google::protobuf::Metadata GetMetadata() const;
 
  // nested types ----------------------------------------------------
 
  // accessors -------------------------------------------------------
 
  // optional bool deprecated_32_bit = 4;
  inline bool has_deprecated_32_bit() const;
  inline void clear_deprecated_32_bit();
  static const int kDeprecated32BitFieldNumber = 4;
  inline bool deprecated_32_bit() const;
  inline void set_deprecated_32_bit(bool value);
 
  // @@protoc_insertion_point(class_scope:bgs.protocol.SDKFieldOptions)
 private:
  inline void set_has_deprecated_32_bit();
  inline void clear_has_deprecated_32_bit();
 
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
 
  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  bool deprecated_32_bit_;
  friend void TC_PROTO_API protobuf_AddDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_AssignDesc_global_5fextensions_2ffield_5foptions_2eproto();
  friend void protobuf_ShutdownFile_global_5fextensions_2ffield_5foptions_2eproto();
 
  void InitAsDefaultInstance();
  static SDKFieldOptions* default_instance_;
};
// ===================================================================
 
// ===================================================================
 
static const int kFieldOptionsFieldNumber = 90000;
TC_PROTO_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FieldOptions,
    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::BGSFieldOptions >, 11, false >
  field_options;
static const int kValidFieldNumber = 90001;
TC_PROTO_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FieldOptions,
    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::FieldRestriction >, 11, false >
  valid;
static const int kSdkFieldOptionsFieldNumber = 90002;
TC_PROTO_API extern ::google::protobuf::internal::ExtensionIdentifier< ::google::protobuf::FieldOptions,
    ::google::protobuf::internal::MessageTypeTraits< ::bgs::protocol::SDKFieldOptions >, 11, false >
  sdk_field_options;
 
// ===================================================================
 
// BGSFieldOptions
 
// optional .bgs.protocol.LogOption log = 1;
inline bool BGSFieldOptions::has_log() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void BGSFieldOptions::set_has_log() {
  _has_bits_[0] |= 0x00000001u;
}
inline void BGSFieldOptions::clear_has_log() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void BGSFieldOptions::clear_log() {
  log_ = 1;
  clear_has_log();
}
inline ::bgs::protocol::LogOption BGSFieldOptions::log() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.BGSFieldOptions.log)
  return static_cast< ::bgs::protocol::LogOption >(log_);
}
inline void BGSFieldOptions::set_log(::bgs::protocol::LogOption value) {
  assert(::bgs::protocol::LogOption_IsValid(value));
  set_has_log();
  log_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.BGSFieldOptions.log)
}
 
// optional bool shard_key = 2;
inline bool BGSFieldOptions::has_shard_key() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void BGSFieldOptions::set_has_shard_key() {
  _has_bits_[0] |= 0x00000002u;
}
inline void BGSFieldOptions::clear_has_shard_key() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void BGSFieldOptions::clear_shard_key() {
  shard_key_ = false;
  clear_has_shard_key();
}
inline bool BGSFieldOptions::shard_key() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.BGSFieldOptions.shard_key)
  return shard_key_;
}
inline void BGSFieldOptions::set_shard_key(bool value) {
  set_has_shard_key();
  shard_key_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.BGSFieldOptions.shard_key)
}
 
// optional bool fanout_key = 3;
inline bool BGSFieldOptions::has_fanout_key() const {
  return (_has_bits_[0] & 0x00000004u) != 0;
}
inline void BGSFieldOptions::set_has_fanout_key() {
  _has_bits_[0] |= 0x00000004u;
}
inline void BGSFieldOptions::clear_has_fanout_key() {
  _has_bits_[0] &= ~0x00000004u;
}
inline void BGSFieldOptions::clear_fanout_key() {
  fanout_key_ = false;
  clear_has_fanout_key();
}
inline bool BGSFieldOptions::fanout_key() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.BGSFieldOptions.fanout_key)
  return fanout_key_;
}
inline void BGSFieldOptions::set_fanout_key(bool value) {
  set_has_fanout_key();
  fanout_key_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.BGSFieldOptions.fanout_key)
}
 
// optional bool client_instance_key = 4;
inline bool BGSFieldOptions::has_client_instance_key() const {
  return (_has_bits_[0] & 0x00000008u) != 0;
}
inline void BGSFieldOptions::set_has_client_instance_key() {
  _has_bits_[0] |= 0x00000008u;
}
inline void BGSFieldOptions::clear_has_client_instance_key() {
  _has_bits_[0] &= ~0x00000008u;
}
inline void BGSFieldOptions::clear_client_instance_key() {
  client_instance_key_ = false;
  clear_has_client_instance_key();
}
inline bool BGSFieldOptions::client_instance_key() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.BGSFieldOptions.client_instance_key)
  return client_instance_key_;
}
inline void BGSFieldOptions::set_client_instance_key(bool value) {
  set_has_client_instance_key();
  client_instance_key_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.BGSFieldOptions.client_instance_key)
}
 
// optional string realized_enum = 5;
inline bool BGSFieldOptions::has_realized_enum() const {
  return (_has_bits_[0] & 0x00000010u) != 0;
}
inline void BGSFieldOptions::set_has_realized_enum() {
  _has_bits_[0] |= 0x00000010u;
}
inline void BGSFieldOptions::clear_has_realized_enum() {
  _has_bits_[0] &= ~0x00000010u;
}
inline void BGSFieldOptions::clear_realized_enum() {
  if (realized_enum_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    realized_enum_->clear();
  }
  clear_has_realized_enum();
}
inline const ::std::string& BGSFieldOptions::realized_enum() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.BGSFieldOptions.realized_enum)
  return *realized_enum_;
}
inline void BGSFieldOptions::set_realized_enum(const ::std::string& value) {
  set_has_realized_enum();
  if (realized_enum_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    realized_enum_ = new ::std::string;
  }
  realized_enum_->assign(value);
  // @@protoc_insertion_point(field_set:bgs.protocol.BGSFieldOptions.realized_enum)
}
inline void BGSFieldOptions::set_realized_enum(const char* value) {
  set_has_realized_enum();
  if (realized_enum_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    realized_enum_ = new ::std::string;
  }
  realized_enum_->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.BGSFieldOptions.realized_enum)
}
inline void BGSFieldOptions::set_realized_enum(const char* value, size_t size) {
  set_has_realized_enum();
  if (realized_enum_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    realized_enum_ = new ::std::string;
  }
  realized_enum_->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.BGSFieldOptions.realized_enum)
}
inline ::std::string* BGSFieldOptions::mutable_realized_enum() {
  set_has_realized_enum();
  if (realized_enum_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    realized_enum_ = new ::std::string;
  }
  // @@protoc_insertion_point(field_mutable:bgs.protocol.BGSFieldOptions.realized_enum)
  return realized_enum_;
}
inline ::std::string* BGSFieldOptions::release_realized_enum() {
  clear_has_realized_enum();
  if (realized_enum_ == &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    return NULL;
  } else {
    ::std::string* temp = realized_enum_;
    realized_enum_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
    return temp;
  }
}
inline void BGSFieldOptions::set_allocated_realized_enum(::std::string* realized_enum) {
  if (realized_enum_ != &::google::protobuf::internal::GetEmptyStringAlreadyInited()) {
    delete realized_enum_;
  }
  if (realized_enum) {
    set_has_realized_enum();
    realized_enum_ = realized_enum;
  } else {
    clear_has_realized_enum();
    realized_enum_ = const_cast< ::std::string*>(&::google::protobuf::internal::GetEmptyStringAlreadyInited());
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.BGSFieldOptions.realized_enum)
}
 
// -------------------------------------------------------------------
 
// FieldRestriction
 
// optional .bgs.protocol.SignedFieldRestriction signed = 1;
inline bool FieldRestriction::has_signed_() const {
  return type_case() == kSigned;
}
inline void FieldRestriction::set_has_signed_() {
  _oneof_case_[0] = kSigned;
}
inline void FieldRestriction::clear_signed_() {
  if (has_signed_()) {
    delete type_.signed__;
    clear_has_type();
  }
}
inline const ::bgs::protocol::SignedFieldRestriction& FieldRestriction::signed_() const {
  return has_signed_() ? *type_.signed__
                      : ::bgs::protocol::SignedFieldRestriction::default_instance();
}
inline ::bgs::protocol::SignedFieldRestriction* FieldRestriction::mutable_signed_() {
  if (!has_signed_()) {
    clear_type();
    set_has_signed_();
    type_.signed__ = new ::bgs::protocol::SignedFieldRestriction;
  }
  return type_.signed__;
}
inline ::bgs::protocol::SignedFieldRestriction* FieldRestriction::release_signed_() {
  if (has_signed_()) {
    clear_has_type();
    ::bgs::protocol::SignedFieldRestriction* temp = type_.signed__;
    type_.signed__ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void FieldRestriction::set_allocated_signed_(::bgs::protocol::SignedFieldRestriction* signed_) {
  clear_type();
  if (signed_) {
    set_has_signed_();
    type_.signed__ = signed_;
  }
}
 
// optional .bgs.protocol.UnsignedFieldRestriction unsigned = 2;
inline bool FieldRestriction::has_unsigned_() const {
  return type_case() == kUnsigned;
}
inline void FieldRestriction::set_has_unsigned_() {
  _oneof_case_[0] = kUnsigned;
}
inline void FieldRestriction::clear_unsigned_() {
  if (has_unsigned_()) {
    delete type_.unsigned__;
    clear_has_type();
  }
}
inline const ::bgs::protocol::UnsignedFieldRestriction& FieldRestriction::unsigned_() const {
  return has_unsigned_() ? *type_.unsigned__
                      : ::bgs::protocol::UnsignedFieldRestriction::default_instance();
}
inline ::bgs::protocol::UnsignedFieldRestriction* FieldRestriction::mutable_unsigned_() {
  if (!has_unsigned_()) {
    clear_type();
    set_has_unsigned_();
    type_.unsigned__ = new ::bgs::protocol::UnsignedFieldRestriction;
  }
  return type_.unsigned__;
}
inline ::bgs::protocol::UnsignedFieldRestriction* FieldRestriction::release_unsigned_() {
  if (has_unsigned_()) {
    clear_has_type();
    ::bgs::protocol::UnsignedFieldRestriction* temp = type_.unsigned__;
    type_.unsigned__ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void FieldRestriction::set_allocated_unsigned_(::bgs::protocol::UnsignedFieldRestriction* unsigned_) {
  clear_type();
  if (unsigned_) {
    set_has_unsigned_();
    type_.unsigned__ = unsigned_;
  }
}
 
// optional .bgs.protocol.FloatFieldRestriction float = 3;
inline bool FieldRestriction::has_float_() const {
  return type_case() == kFloat;
}
inline void FieldRestriction::set_has_float_() {
  _oneof_case_[0] = kFloat;
}
inline void FieldRestriction::clear_float_() {
  if (has_float_()) {
    delete type_.float__;
    clear_has_type();
  }
}
inline const ::bgs::protocol::FloatFieldRestriction& FieldRestriction::float_() const {
  return has_float_() ? *type_.float__
                      : ::bgs::protocol::FloatFieldRestriction::default_instance();
}
inline ::bgs::protocol::FloatFieldRestriction* FieldRestriction::mutable_float_() {
  if (!has_float_()) {
    clear_type();
    set_has_float_();
    type_.float__ = new ::bgs::protocol::FloatFieldRestriction;
  }
  return type_.float__;
}
inline ::bgs::protocol::FloatFieldRestriction* FieldRestriction::release_float_() {
  if (has_float_()) {
    clear_has_type();
    ::bgs::protocol::FloatFieldRestriction* temp = type_.float__;
    type_.float__ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void FieldRestriction::set_allocated_float_(::bgs::protocol::FloatFieldRestriction* float_) {
  clear_type();
  if (float_) {
    set_has_float_();
    type_.float__ = float_;
  }
}
 
// optional .bgs.protocol.StringFieldRestriction string = 4;
inline bool FieldRestriction::has_string() const {
  return type_case() == kString;
}
inline void FieldRestriction::set_has_string() {
  _oneof_case_[0] = kString;
}
inline void FieldRestriction::clear_string() {
  if (has_string()) {
    delete type_.string_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::StringFieldRestriction& FieldRestriction::string() const {
  return has_string() ? *type_.string_
                      : ::bgs::protocol::StringFieldRestriction::default_instance();
}
inline ::bgs::protocol::StringFieldRestriction* FieldRestriction::mutable_string() {
  if (!has_string()) {
    clear_type();
    set_has_string();
    type_.string_ = new ::bgs::protocol::StringFieldRestriction;
  }
  return type_.string_;
}
inline ::bgs::protocol::StringFieldRestriction* FieldRestriction::release_string() {
  if (has_string()) {
    clear_has_type();
    ::bgs::protocol::StringFieldRestriction* temp = type_.string_;
    type_.string_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void FieldRestriction::set_allocated_string(::bgs::protocol::StringFieldRestriction* string) {
  clear_type();
  if (string) {
    set_has_string();
    type_.string_ = string;
  }
}
 
// optional .bgs.protocol.RepeatedFieldRestriction repeated = 5;
inline bool FieldRestriction::has_repeated() const {
  return type_case() == kRepeated;
}
inline void FieldRestriction::set_has_repeated() {
  _oneof_case_[0] = kRepeated;
}
inline void FieldRestriction::clear_repeated() {
  if (has_repeated()) {
    delete type_.repeated_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::RepeatedFieldRestriction& FieldRestriction::repeated() const {
  return has_repeated() ? *type_.repeated_
                      : ::bgs::protocol::RepeatedFieldRestriction::default_instance();
}
inline ::bgs::protocol::RepeatedFieldRestriction* FieldRestriction::mutable_repeated() {
  if (!has_repeated()) {
    clear_type();
    set_has_repeated();
    type_.repeated_ = new ::bgs::protocol::RepeatedFieldRestriction;
  }
  return type_.repeated_;
}
inline ::bgs::protocol::RepeatedFieldRestriction* FieldRestriction::release_repeated() {
  if (has_repeated()) {
    clear_has_type();
    ::bgs::protocol::RepeatedFieldRestriction* temp = type_.repeated_;
    type_.repeated_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void FieldRestriction::set_allocated_repeated(::bgs::protocol::RepeatedFieldRestriction* repeated) {
  clear_type();
  if (repeated) {
    set_has_repeated();
    type_.repeated_ = repeated;
  }
}
 
// optional .bgs.protocol.MessageFieldRestriction message = 6;
inline bool FieldRestriction::has_message() const {
  return type_case() == kMessage;
}
inline void FieldRestriction::set_has_message() {
  _oneof_case_[0] = kMessage;
}
inline void FieldRestriction::clear_message() {
  if (has_message()) {
    delete type_.message_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::MessageFieldRestriction& FieldRestriction::message() const {
  return has_message() ? *type_.message_
                      : ::bgs::protocol::MessageFieldRestriction::default_instance();
}
inline ::bgs::protocol::MessageFieldRestriction* FieldRestriction::mutable_message() {
  if (!has_message()) {
    clear_type();
    set_has_message();
    type_.message_ = new ::bgs::protocol::MessageFieldRestriction;
  }
  return type_.message_;
}
inline ::bgs::protocol::MessageFieldRestriction* FieldRestriction::release_message() {
  if (has_message()) {
    clear_has_type();
    ::bgs::protocol::MessageFieldRestriction* temp = type_.message_;
    type_.message_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void FieldRestriction::set_allocated_message(::bgs::protocol::MessageFieldRestriction* message) {
  clear_type();
  if (message) {
    set_has_message();
    type_.message_ = message;
  }
}
 
// optional .bgs.protocol.EntityIdRestriction entity_id = 7;
inline bool FieldRestriction::has_entity_id() const {
  return type_case() == kEntityId;
}
inline void FieldRestriction::set_has_entity_id() {
  _oneof_case_[0] = kEntityId;
}
inline void FieldRestriction::clear_entity_id() {
  if (has_entity_id()) {
    delete type_.entity_id_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::EntityIdRestriction& FieldRestriction::entity_id() const {
  return has_entity_id() ? *type_.entity_id_
                      : ::bgs::protocol::EntityIdRestriction::default_instance();
}
inline ::bgs::protocol::EntityIdRestriction* FieldRestriction::mutable_entity_id() {
  if (!has_entity_id()) {
    clear_type();
    set_has_entity_id();
    type_.entity_id_ = new ::bgs::protocol::EntityIdRestriction;
  }
  return type_.entity_id_;
}
inline ::bgs::protocol::EntityIdRestriction* FieldRestriction::release_entity_id() {
  if (has_entity_id()) {
    clear_has_type();
    ::bgs::protocol::EntityIdRestriction* temp = type_.entity_id_;
    type_.entity_id_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void FieldRestriction::set_allocated_entity_id(::bgs::protocol::EntityIdRestriction* entity_id) {
  clear_type();
  if (entity_id) {
    set_has_entity_id();
    type_.entity_id_ = entity_id;
  }
}
 
// optional .bgs.protocol.StringFieldRestriction bytes = 8;
inline bool FieldRestriction::has_bytes() const {
  return type_case() == kBytes;
}
inline void FieldRestriction::set_has_bytes() {
  _oneof_case_[0] = kBytes;
}
inline void FieldRestriction::clear_bytes() {
  if (has_bytes()) {
    delete type_.bytes_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::StringFieldRestriction& FieldRestriction::bytes() const {
  return has_bytes() ? *type_.bytes_
                      : ::bgs::protocol::StringFieldRestriction::default_instance();
}
inline ::bgs::protocol::StringFieldRestriction* FieldRestriction::mutable_bytes() {
  if (!has_bytes()) {
    clear_type();
    set_has_bytes();
    type_.bytes_ = new ::bgs::protocol::StringFieldRestriction;
  }
  return type_.bytes_;
}
inline ::bgs::protocol::StringFieldRestriction* FieldRestriction::release_bytes() {
  if (has_bytes()) {
    clear_has_type();
    ::bgs::protocol::StringFieldRestriction* temp = type_.bytes_;
    type_.bytes_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void FieldRestriction::set_allocated_bytes(::bgs::protocol::StringFieldRestriction* bytes) {
  clear_type();
  if (bytes) {
    set_has_bytes();
    type_.bytes_ = bytes;
  }
}
 
inline bool FieldRestriction::has_type() {
  return type_case() != TYPE_NOT_SET;
}
inline void FieldRestriction::clear_has_type() {
  _oneof_case_[0] = TYPE_NOT_SET;
}
inline FieldRestriction::TypeCase FieldRestriction::type_case() const {
  return FieldRestriction::TypeCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
 
// RepeatedFieldRestriction
 
// optional .bgs.protocol.UnsignedIntRange size = 1;
inline bool RepeatedFieldRestriction::has_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void RepeatedFieldRestriction::set_has_size() {
  _has_bits_[0] |= 0x00000001u;
}
inline void RepeatedFieldRestriction::clear_has_size() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void RepeatedFieldRestriction::clear_size() {
  if (size_ != NULL) size_->::bgs::protocol::UnsignedIntRange::Clear();
  clear_has_size();
}
inline const ::bgs::protocol::UnsignedIntRange& RepeatedFieldRestriction::size() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.RepeatedFieldRestriction.size)
  return size_ != NULL ? *size_ : *default_instance_->size_;
}
inline ::bgs::protocol::UnsignedIntRange* RepeatedFieldRestriction::mutable_size() {
  set_has_size();
  if (size_ == NULL) size_ = new ::bgs::protocol::UnsignedIntRange;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.RepeatedFieldRestriction.size)
  return size_;
}
inline ::bgs::protocol::UnsignedIntRange* RepeatedFieldRestriction::release_size() {
  clear_has_size();
  ::bgs::protocol::UnsignedIntRange* temp = size_;
  size_ = NULL;
  return temp;
}
inline void RepeatedFieldRestriction::set_allocated_size(::bgs::protocol::UnsignedIntRange* size) {
  delete size_;
  size_ = size;
  if (size) {
    set_has_size();
  } else {
    clear_has_size();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.RepeatedFieldRestriction.size)
}
 
// optional bool unique = 2;
inline bool RepeatedFieldRestriction::has_unique() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void RepeatedFieldRestriction::set_has_unique() {
  _has_bits_[0] |= 0x00000002u;
}
inline void RepeatedFieldRestriction::clear_has_unique() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void RepeatedFieldRestriction::clear_unique() {
  unique_ = false;
  clear_has_unique();
}
inline bool RepeatedFieldRestriction::unique() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.RepeatedFieldRestriction.unique)
  return unique_;
}
inline void RepeatedFieldRestriction::set_unique(bool value) {
  set_has_unique();
  unique_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.RepeatedFieldRestriction.unique)
}
 
// optional .bgs.protocol.SignedFieldRestriction signed = 3;
inline bool RepeatedFieldRestriction::has_signed_() const {
  return type_case() == kSigned;
}
inline void RepeatedFieldRestriction::set_has_signed_() {
  _oneof_case_[0] = kSigned;
}
inline void RepeatedFieldRestriction::clear_signed_() {
  if (has_signed_()) {
    delete type_.signed__;
    clear_has_type();
  }
}
inline const ::bgs::protocol::SignedFieldRestriction& RepeatedFieldRestriction::signed_() const {
  return has_signed_() ? *type_.signed__
                      : ::bgs::protocol::SignedFieldRestriction::default_instance();
}
inline ::bgs::protocol::SignedFieldRestriction* RepeatedFieldRestriction::mutable_signed_() {
  if (!has_signed_()) {
    clear_type();
    set_has_signed_();
    type_.signed__ = new ::bgs::protocol::SignedFieldRestriction;
  }
  return type_.signed__;
}
inline ::bgs::protocol::SignedFieldRestriction* RepeatedFieldRestriction::release_signed_() {
  if (has_signed_()) {
    clear_has_type();
    ::bgs::protocol::SignedFieldRestriction* temp = type_.signed__;
    type_.signed__ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void RepeatedFieldRestriction::set_allocated_signed_(::bgs::protocol::SignedFieldRestriction* signed_) {
  clear_type();
  if (signed_) {
    set_has_signed_();
    type_.signed__ = signed_;
  }
}
 
// optional .bgs.protocol.UnsignedFieldRestriction unsigned = 4;
inline bool RepeatedFieldRestriction::has_unsigned_() const {
  return type_case() == kUnsigned;
}
inline void RepeatedFieldRestriction::set_has_unsigned_() {
  _oneof_case_[0] = kUnsigned;
}
inline void RepeatedFieldRestriction::clear_unsigned_() {
  if (has_unsigned_()) {
    delete type_.unsigned__;
    clear_has_type();
  }
}
inline const ::bgs::protocol::UnsignedFieldRestriction& RepeatedFieldRestriction::unsigned_() const {
  return has_unsigned_() ? *type_.unsigned__
                      : ::bgs::protocol::UnsignedFieldRestriction::default_instance();
}
inline ::bgs::protocol::UnsignedFieldRestriction* RepeatedFieldRestriction::mutable_unsigned_() {
  if (!has_unsigned_()) {
    clear_type();
    set_has_unsigned_();
    type_.unsigned__ = new ::bgs::protocol::UnsignedFieldRestriction;
  }
  return type_.unsigned__;
}
inline ::bgs::protocol::UnsignedFieldRestriction* RepeatedFieldRestriction::release_unsigned_() {
  if (has_unsigned_()) {
    clear_has_type();
    ::bgs::protocol::UnsignedFieldRestriction* temp = type_.unsigned__;
    type_.unsigned__ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void RepeatedFieldRestriction::set_allocated_unsigned_(::bgs::protocol::UnsignedFieldRestriction* unsigned_) {
  clear_type();
  if (unsigned_) {
    set_has_unsigned_();
    type_.unsigned__ = unsigned_;
  }
}
 
// optional .bgs.protocol.FloatFieldRestriction float = 5;
inline bool RepeatedFieldRestriction::has_float_() const {
  return type_case() == kFloat;
}
inline void RepeatedFieldRestriction::set_has_float_() {
  _oneof_case_[0] = kFloat;
}
inline void RepeatedFieldRestriction::clear_float_() {
  if (has_float_()) {
    delete type_.float__;
    clear_has_type();
  }
}
inline const ::bgs::protocol::FloatFieldRestriction& RepeatedFieldRestriction::float_() const {
  return has_float_() ? *type_.float__
                      : ::bgs::protocol::FloatFieldRestriction::default_instance();
}
inline ::bgs::protocol::FloatFieldRestriction* RepeatedFieldRestriction::mutable_float_() {
  if (!has_float_()) {
    clear_type();
    set_has_float_();
    type_.float__ = new ::bgs::protocol::FloatFieldRestriction;
  }
  return type_.float__;
}
inline ::bgs::protocol::FloatFieldRestriction* RepeatedFieldRestriction::release_float_() {
  if (has_float_()) {
    clear_has_type();
    ::bgs::protocol::FloatFieldRestriction* temp = type_.float__;
    type_.float__ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void RepeatedFieldRestriction::set_allocated_float_(::bgs::protocol::FloatFieldRestriction* float_) {
  clear_type();
  if (float_) {
    set_has_float_();
    type_.float__ = float_;
  }
}
 
// optional .bgs.protocol.StringFieldRestriction string = 6;
inline bool RepeatedFieldRestriction::has_string() const {
  return type_case() == kString;
}
inline void RepeatedFieldRestriction::set_has_string() {
  _oneof_case_[0] = kString;
}
inline void RepeatedFieldRestriction::clear_string() {
  if (has_string()) {
    delete type_.string_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::StringFieldRestriction& RepeatedFieldRestriction::string() const {
  return has_string() ? *type_.string_
                      : ::bgs::protocol::StringFieldRestriction::default_instance();
}
inline ::bgs::protocol::StringFieldRestriction* RepeatedFieldRestriction::mutable_string() {
  if (!has_string()) {
    clear_type();
    set_has_string();
    type_.string_ = new ::bgs::protocol::StringFieldRestriction;
  }
  return type_.string_;
}
inline ::bgs::protocol::StringFieldRestriction* RepeatedFieldRestriction::release_string() {
  if (has_string()) {
    clear_has_type();
    ::bgs::protocol::StringFieldRestriction* temp = type_.string_;
    type_.string_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void RepeatedFieldRestriction::set_allocated_string(::bgs::protocol::StringFieldRestriction* string) {
  clear_type();
  if (string) {
    set_has_string();
    type_.string_ = string;
  }
}
 
// optional .bgs.protocol.EntityIdRestriction entity_id = 7;
inline bool RepeatedFieldRestriction::has_entity_id() const {
  return type_case() == kEntityId;
}
inline void RepeatedFieldRestriction::set_has_entity_id() {
  _oneof_case_[0] = kEntityId;
}
inline void RepeatedFieldRestriction::clear_entity_id() {
  if (has_entity_id()) {
    delete type_.entity_id_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::EntityIdRestriction& RepeatedFieldRestriction::entity_id() const {
  return has_entity_id() ? *type_.entity_id_
                      : ::bgs::protocol::EntityIdRestriction::default_instance();
}
inline ::bgs::protocol::EntityIdRestriction* RepeatedFieldRestriction::mutable_entity_id() {
  if (!has_entity_id()) {
    clear_type();
    set_has_entity_id();
    type_.entity_id_ = new ::bgs::protocol::EntityIdRestriction;
  }
  return type_.entity_id_;
}
inline ::bgs::protocol::EntityIdRestriction* RepeatedFieldRestriction::release_entity_id() {
  if (has_entity_id()) {
    clear_has_type();
    ::bgs::protocol::EntityIdRestriction* temp = type_.entity_id_;
    type_.entity_id_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void RepeatedFieldRestriction::set_allocated_entity_id(::bgs::protocol::EntityIdRestriction* entity_id) {
  clear_type();
  if (entity_id) {
    set_has_entity_id();
    type_.entity_id_ = entity_id;
  }
}
 
// optional .bgs.protocol.StringFieldRestriction bytes = 8;
inline bool RepeatedFieldRestriction::has_bytes() const {
  return type_case() == kBytes;
}
inline void RepeatedFieldRestriction::set_has_bytes() {
  _oneof_case_[0] = kBytes;
}
inline void RepeatedFieldRestriction::clear_bytes() {
  if (has_bytes()) {
    delete type_.bytes_;
    clear_has_type();
  }
}
inline const ::bgs::protocol::StringFieldRestriction& RepeatedFieldRestriction::bytes() const {
  return has_bytes() ? *type_.bytes_
                      : ::bgs::protocol::StringFieldRestriction::default_instance();
}
inline ::bgs::protocol::StringFieldRestriction* RepeatedFieldRestriction::mutable_bytes() {
  if (!has_bytes()) {
    clear_type();
    set_has_bytes();
    type_.bytes_ = new ::bgs::protocol::StringFieldRestriction;
  }
  return type_.bytes_;
}
inline ::bgs::protocol::StringFieldRestriction* RepeatedFieldRestriction::release_bytes() {
  if (has_bytes()) {
    clear_has_type();
    ::bgs::protocol::StringFieldRestriction* temp = type_.bytes_;
    type_.bytes_ = NULL;
    return temp;
  } else {
    return NULL;
  }
}
inline void RepeatedFieldRestriction::set_allocated_bytes(::bgs::protocol::StringFieldRestriction* bytes) {
  clear_type();
  if (bytes) {
    set_has_bytes();
    type_.bytes_ = bytes;
  }
}
 
inline bool RepeatedFieldRestriction::has_type() {
  return type_case() != TYPE_NOT_SET;
}
inline void RepeatedFieldRestriction::clear_has_type() {
  _oneof_case_[0] = TYPE_NOT_SET;
}
inline RepeatedFieldRestriction::TypeCase RepeatedFieldRestriction::type_case() const {
  return RepeatedFieldRestriction::TypeCase(_oneof_case_[0]);
}
// -------------------------------------------------------------------
 
// SignedFieldRestriction
 
// optional .bgs.protocol.SignedIntRange limits = 1;
inline bool SignedFieldRestriction::has_limits() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SignedFieldRestriction::set_has_limits() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SignedFieldRestriction::clear_has_limits() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SignedFieldRestriction::clear_limits() {
  if (limits_ != NULL) limits_->::bgs::protocol::SignedIntRange::Clear();
  clear_has_limits();
}
inline const ::bgs::protocol::SignedIntRange& SignedFieldRestriction::limits() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.SignedFieldRestriction.limits)
  return limits_ != NULL ? *limits_ : *default_instance_->limits_;
}
inline ::bgs::protocol::SignedIntRange* SignedFieldRestriction::mutable_limits() {
  set_has_limits();
  if (limits_ == NULL) limits_ = new ::bgs::protocol::SignedIntRange;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.SignedFieldRestriction.limits)
  return limits_;
}
inline ::bgs::protocol::SignedIntRange* SignedFieldRestriction::release_limits() {
  clear_has_limits();
  ::bgs::protocol::SignedIntRange* temp = limits_;
  limits_ = NULL;
  return temp;
}
inline void SignedFieldRestriction::set_allocated_limits(::bgs::protocol::SignedIntRange* limits) {
  delete limits_;
  limits_ = limits;
  if (limits) {
    set_has_limits();
  } else {
    clear_has_limits();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.SignedFieldRestriction.limits)
}
 
// repeated sint64 exclude = 2;
inline int SignedFieldRestriction::exclude_size() const {
  return exclude_.size();
}
inline void SignedFieldRestriction::clear_exclude() {
  exclude_.Clear();
}
inline ::google::protobuf::int64 SignedFieldRestriction::exclude(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.SignedFieldRestriction.exclude)
  return exclude_.Get(index);
}
inline void SignedFieldRestriction::set_exclude(int index, ::google::protobuf::int64 value) {
  exclude_.Set(index, value);
  // @@protoc_insertion_point(field_set:bgs.protocol.SignedFieldRestriction.exclude)
}
inline void SignedFieldRestriction::add_exclude(::google::protobuf::int64 value) {
  exclude_.Add(value);
  // @@protoc_insertion_point(field_add:bgs.protocol.SignedFieldRestriction.exclude)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::int64 >&
SignedFieldRestriction::exclude() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.SignedFieldRestriction.exclude)
  return exclude_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::int64 >*
SignedFieldRestriction::mutable_exclude() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.SignedFieldRestriction.exclude)
  return &exclude_;
}
 
// -------------------------------------------------------------------
 
// UnsignedFieldRestriction
 
// optional .bgs.protocol.UnsignedIntRange limits = 1;
inline bool UnsignedFieldRestriction::has_limits() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void UnsignedFieldRestriction::set_has_limits() {
  _has_bits_[0] |= 0x00000001u;
}
inline void UnsignedFieldRestriction::clear_has_limits() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void UnsignedFieldRestriction::clear_limits() {
  if (limits_ != NULL) limits_->::bgs::protocol::UnsignedIntRange::Clear();
  clear_has_limits();
}
inline const ::bgs::protocol::UnsignedIntRange& UnsignedFieldRestriction::limits() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.UnsignedFieldRestriction.limits)
  return limits_ != NULL ? *limits_ : *default_instance_->limits_;
}
inline ::bgs::protocol::UnsignedIntRange* UnsignedFieldRestriction::mutable_limits() {
  set_has_limits();
  if (limits_ == NULL) limits_ = new ::bgs::protocol::UnsignedIntRange;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.UnsignedFieldRestriction.limits)
  return limits_;
}
inline ::bgs::protocol::UnsignedIntRange* UnsignedFieldRestriction::release_limits() {
  clear_has_limits();
  ::bgs::protocol::UnsignedIntRange* temp = limits_;
  limits_ = NULL;
  return temp;
}
inline void UnsignedFieldRestriction::set_allocated_limits(::bgs::protocol::UnsignedIntRange* limits) {
  delete limits_;
  limits_ = limits;
  if (limits) {
    set_has_limits();
  } else {
    clear_has_limits();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.UnsignedFieldRestriction.limits)
}
 
// repeated uint64 exclude = 2;
inline int UnsignedFieldRestriction::exclude_size() const {
  return exclude_.size();
}
inline void UnsignedFieldRestriction::clear_exclude() {
  exclude_.Clear();
}
inline ::google::protobuf::uint64 UnsignedFieldRestriction::exclude(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.UnsignedFieldRestriction.exclude)
  return exclude_.Get(index);
}
inline void UnsignedFieldRestriction::set_exclude(int index, ::google::protobuf::uint64 value) {
  exclude_.Set(index, value);
  // @@protoc_insertion_point(field_set:bgs.protocol.UnsignedFieldRestriction.exclude)
}
inline void UnsignedFieldRestriction::add_exclude(::google::protobuf::uint64 value) {
  exclude_.Add(value);
  // @@protoc_insertion_point(field_add:bgs.protocol.UnsignedFieldRestriction.exclude)
}
inline const ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >&
UnsignedFieldRestriction::exclude() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.UnsignedFieldRestriction.exclude)
  return exclude_;
}
inline ::google::protobuf::RepeatedField< ::google::protobuf::uint64 >*
UnsignedFieldRestriction::mutable_exclude() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.UnsignedFieldRestriction.exclude)
  return &exclude_;
}
 
// -------------------------------------------------------------------
 
// FloatFieldRestriction
 
// optional .bgs.protocol.FloatRange limits = 1;
inline bool FloatFieldRestriction::has_limits() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void FloatFieldRestriction::set_has_limits() {
  _has_bits_[0] |= 0x00000001u;
}
inline void FloatFieldRestriction::clear_has_limits() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void FloatFieldRestriction::clear_limits() {
  if (limits_ != NULL) limits_->::bgs::protocol::FloatRange::Clear();
  clear_has_limits();
}
inline const ::bgs::protocol::FloatRange& FloatFieldRestriction::limits() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.FloatFieldRestriction.limits)
  return limits_ != NULL ? *limits_ : *default_instance_->limits_;
}
inline ::bgs::protocol::FloatRange* FloatFieldRestriction::mutable_limits() {
  set_has_limits();
  if (limits_ == NULL) limits_ = new ::bgs::protocol::FloatRange;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.FloatFieldRestriction.limits)
  return limits_;
}
inline ::bgs::protocol::FloatRange* FloatFieldRestriction::release_limits() {
  clear_has_limits();
  ::bgs::protocol::FloatRange* temp = limits_;
  limits_ = NULL;
  return temp;
}
inline void FloatFieldRestriction::set_allocated_limits(::bgs::protocol::FloatRange* limits) {
  delete limits_;
  limits_ = limits;
  if (limits) {
    set_has_limits();
  } else {
    clear_has_limits();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.FloatFieldRestriction.limits)
}
 
// repeated float exclude = 2;
inline int FloatFieldRestriction::exclude_size() const {
  return exclude_.size();
}
inline void FloatFieldRestriction::clear_exclude() {
  exclude_.Clear();
}
inline float FloatFieldRestriction::exclude(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.FloatFieldRestriction.exclude)
  return exclude_.Get(index);
}
inline void FloatFieldRestriction::set_exclude(int index, float value) {
  exclude_.Set(index, value);
  // @@protoc_insertion_point(field_set:bgs.protocol.FloatFieldRestriction.exclude)
}
inline void FloatFieldRestriction::add_exclude(float value) {
  exclude_.Add(value);
  // @@protoc_insertion_point(field_add:bgs.protocol.FloatFieldRestriction.exclude)
}
inline const ::google::protobuf::RepeatedField< float >&
FloatFieldRestriction::exclude() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.FloatFieldRestriction.exclude)
  return exclude_;
}
inline ::google::protobuf::RepeatedField< float >*
FloatFieldRestriction::mutable_exclude() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.FloatFieldRestriction.exclude)
  return &exclude_;
}
 
// -------------------------------------------------------------------
 
// StringFieldRestriction
 
// optional .bgs.protocol.UnsignedIntRange size = 1;
inline bool StringFieldRestriction::has_size() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void StringFieldRestriction::set_has_size() {
  _has_bits_[0] |= 0x00000001u;
}
inline void StringFieldRestriction::clear_has_size() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void StringFieldRestriction::clear_size() {
  if (size_ != NULL) size_->::bgs::protocol::UnsignedIntRange::Clear();
  clear_has_size();
}
inline const ::bgs::protocol::UnsignedIntRange& StringFieldRestriction::size() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.StringFieldRestriction.size)
  return size_ != NULL ? *size_ : *default_instance_->size_;
}
inline ::bgs::protocol::UnsignedIntRange* StringFieldRestriction::mutable_size() {
  set_has_size();
  if (size_ == NULL) size_ = new ::bgs::protocol::UnsignedIntRange;
  // @@protoc_insertion_point(field_mutable:bgs.protocol.StringFieldRestriction.size)
  return size_;
}
inline ::bgs::protocol::UnsignedIntRange* StringFieldRestriction::release_size() {
  clear_has_size();
  ::bgs::protocol::UnsignedIntRange* temp = size_;
  size_ = NULL;
  return temp;
}
inline void StringFieldRestriction::set_allocated_size(::bgs::protocol::UnsignedIntRange* size) {
  delete size_;
  size_ = size;
  if (size) {
    set_has_size();
  } else {
    clear_has_size();
  }
  // @@protoc_insertion_point(field_set_allocated:bgs.protocol.StringFieldRestriction.size)
}
 
// repeated string exclude = 2;
inline int StringFieldRestriction::exclude_size() const {
  return exclude_.size();
}
inline void StringFieldRestriction::clear_exclude() {
  exclude_.Clear();
}
inline const ::std::string& StringFieldRestriction::exclude(int index) const {
  // @@protoc_insertion_point(field_get:bgs.protocol.StringFieldRestriction.exclude)
  return exclude_.Get(index);
}
inline ::std::string* StringFieldRestriction::mutable_exclude(int index) {
  // @@protoc_insertion_point(field_mutable:bgs.protocol.StringFieldRestriction.exclude)
  return exclude_.Mutable(index);
}
inline void StringFieldRestriction::set_exclude(int index, const ::std::string& value) {
  // @@protoc_insertion_point(field_set:bgs.protocol.StringFieldRestriction.exclude)
  exclude_.Mutable(index)->assign(value);
}
inline void StringFieldRestriction::set_exclude(int index, const char* value) {
  exclude_.Mutable(index)->assign(value);
  // @@protoc_insertion_point(field_set_char:bgs.protocol.StringFieldRestriction.exclude)
}
inline void StringFieldRestriction::set_exclude(int index, const char* value, size_t size) {
  exclude_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_set_pointer:bgs.protocol.StringFieldRestriction.exclude)
}
inline ::std::string* StringFieldRestriction::add_exclude() {
  return exclude_.Add();
}
inline void StringFieldRestriction::add_exclude(const ::std::string& value) {
  exclude_.Add()->assign(value);
  // @@protoc_insertion_point(field_add:bgs.protocol.StringFieldRestriction.exclude)
}
inline void StringFieldRestriction::add_exclude(const char* value) {
  exclude_.Add()->assign(value);
  // @@protoc_insertion_point(field_add_char:bgs.protocol.StringFieldRestriction.exclude)
}
inline void StringFieldRestriction::add_exclude(const char* value, size_t size) {
  exclude_.Add()->assign(reinterpret_cast<const char*>(value), size);
  // @@protoc_insertion_point(field_add_pointer:bgs.protocol.StringFieldRestriction.exclude)
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
StringFieldRestriction::exclude() const {
  // @@protoc_insertion_point(field_list:bgs.protocol.StringFieldRestriction.exclude)
  return exclude_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
StringFieldRestriction::mutable_exclude() {
  // @@protoc_insertion_point(field_mutable_list:bgs.protocol.StringFieldRestriction.exclude)
  return &exclude_;
}
 
// -------------------------------------------------------------------
 
// EntityIdRestriction
 
// optional bool needed = 1;
inline bool EntityIdRestriction::has_needed() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void EntityIdRestriction::set_has_needed() {
  _has_bits_[0] |= 0x00000001u;
}
inline void EntityIdRestriction::clear_has_needed() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void EntityIdRestriction::clear_needed() {
  needed_ = false;
  clear_has_needed();
}
inline bool EntityIdRestriction::needed() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.EntityIdRestriction.needed)
  return needed_;
}
inline void EntityIdRestriction::set_needed(bool value) {
  set_has_needed();
  needed_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.EntityIdRestriction.needed)
}
 
// optional .bgs.protocol.EntityIdRestriction.Kind kind = 2;
inline bool EntityIdRestriction::has_kind() const {
  return (_has_bits_[0] & 0x00000002u) != 0;
}
inline void EntityIdRestriction::set_has_kind() {
  _has_bits_[0] |= 0x00000002u;
}
inline void EntityIdRestriction::clear_has_kind() {
  _has_bits_[0] &= ~0x00000002u;
}
inline void EntityIdRestriction::clear_kind() {
  kind_ = 0;
  clear_has_kind();
}
inline ::bgs::protocol::EntityIdRestriction_Kind EntityIdRestriction::kind() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.EntityIdRestriction.kind)
  return static_cast< ::bgs::protocol::EntityIdRestriction_Kind >(kind_);
}
inline void EntityIdRestriction::set_kind(::bgs::protocol::EntityIdRestriction_Kind value) {
  assert(::bgs::protocol::EntityIdRestriction_Kind_IsValid(value));
  set_has_kind();
  kind_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.EntityIdRestriction.kind)
}
 
// -------------------------------------------------------------------
 
// MessageFieldRestriction
 
// optional bool needed = 1;
inline bool MessageFieldRestriction::has_needed() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void MessageFieldRestriction::set_has_needed() {
  _has_bits_[0] |= 0x00000001u;
}
inline void MessageFieldRestriction::clear_has_needed() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void MessageFieldRestriction::clear_needed() {
  needed_ = false;
  clear_has_needed();
}
inline bool MessageFieldRestriction::needed() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.MessageFieldRestriction.needed)
  return needed_;
}
inline void MessageFieldRestriction::set_needed(bool value) {
  set_has_needed();
  needed_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.MessageFieldRestriction.needed)
}
 
// -------------------------------------------------------------------
 
// SDKFieldOptions
 
// optional bool deprecated_32_bit = 4;
inline bool SDKFieldOptions::has_deprecated_32_bit() const {
  return (_has_bits_[0] & 0x00000001u) != 0;
}
inline void SDKFieldOptions::set_has_deprecated_32_bit() {
  _has_bits_[0] |= 0x00000001u;
}
inline void SDKFieldOptions::clear_has_deprecated_32_bit() {
  _has_bits_[0] &= ~0x00000001u;
}
inline void SDKFieldOptions::clear_deprecated_32_bit() {
  deprecated_32_bit_ = false;
  clear_has_deprecated_32_bit();
}
inline bool SDKFieldOptions::deprecated_32_bit() const {
  // @@protoc_insertion_point(field_get:bgs.protocol.SDKFieldOptions.deprecated_32_bit)
  return deprecated_32_bit_;
}
inline void SDKFieldOptions::set_deprecated_32_bit(bool value) {
  set_has_deprecated_32_bit();
  deprecated_32_bit_ = value;
  // @@protoc_insertion_point(field_set:bgs.protocol.SDKFieldOptions.deprecated_32_bit)
}
 
// @@protoc_insertion_point(namespace_scope)
 
}  // namespace protocol
}  // namespace bgs
 
#ifndef SWIG
namespace google {
namespace protobuf {
template <> struct is_proto_enum< ::bgs::protocol::EntityIdRestriction_Kind> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::EntityIdRestriction_Kind>() {
  return ::bgs::protocol::EntityIdRestriction_Kind_descriptor();
}
template <> struct is_proto_enum< ::bgs::protocol::LogOption> : ::google::protobuf::internal::true_type {};
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::bgs::protocol::LogOption>() {
  return ::bgs::protocol::LogOption_descriptor();
}
}  // namespace google
}  // namespace protobuf
#endif  // SWIG
 
// @@protoc_insertion_point(global_scope)
 
#endif  // PROTOBUF_global_5fextensions_2ffield_5foptions_2eproto__INCLUDED