// 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;

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;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const BGSFieldOptions& from);
  void MergeFrom(const BGSFieldOptions& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) 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);

  // @@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();

  ::google::protobuf::UnknownFieldSet _unknown_fields_;

  ::google::protobuf::uint32 _has_bits_[1];
  mutable int _cached_size_;
  int log_;
  bool shard_key_;
  bool fanout_key_;
  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,
    TYPE_NOT_SET = 0,
  };

  void Swap(FieldRestriction* other);

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

  FieldRestriction* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FieldRestriction& from);
  void MergeFrom(const FieldRestriction& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) 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);

  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 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_;
  } 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,
    TYPE_NOT_SET = 0,
  };

  void Swap(RepeatedFieldRestriction* other);

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

  RepeatedFieldRestriction* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const RepeatedFieldRestriction& from);
  void MergeFrom(const RepeatedFieldRestriction& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) 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);

  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 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_;
  } 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;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SignedFieldRestriction& from);
  void MergeFrom(const SignedFieldRestriction& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) 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;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UnsignedFieldRestriction& from);
  void MergeFrom(const UnsignedFieldRestriction& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) 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;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FloatFieldRestriction& from);
  void MergeFrom(const FloatFieldRestriction& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) 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;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const StringFieldRestriction& from);
  void MergeFrom(const StringFieldRestriction& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) 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;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const EntityIdRestriction& from);
  void MergeFrom(const EntityIdRestriction& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) 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;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const MessageFieldRestriction& from);
  void MergeFrom(const MessageFieldRestriction& from);
  void Clear();
  bool IsInitialized() const;

  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) 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_;
};
// ===================================================================


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

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;

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

// 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)
}

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

// 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;
  }
}

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;
  }
}

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)
}


// @@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
