00001
00002
00003 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
00004 #include "replication_options.pb.h"
00005 #include <google/protobuf/stubs/once.h>
00006 #include <google/protobuf/io/coded_stream.h>
00007 #include <google/protobuf/wire_format_lite_inl.h>
00008 #include <google/protobuf/descriptor.h>
00009 #include <google/protobuf/reflection_ops.h>
00010 #include <google/protobuf/wire_format.h>
00011
00012
00013 namespace drizzled {
00014 namespace message {
00015
00016 namespace {
00017
00018 const ::google::protobuf::Descriptor* ReplicationOptions_descriptor_ = NULL;
00019 const ::google::protobuf::internal::GeneratedMessageReflection*
00020 ReplicationOptions_reflection_ = NULL;
00021
00022 }
00023
00024
00025 void protobuf_AssignDesc_replication_5foptions_2eproto() {
00026 protobuf_AddDesc_replication_5foptions_2eproto();
00027 const ::google::protobuf::FileDescriptor* file =
00028 ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
00029 "replication_options.proto");
00030 GOOGLE_CHECK(file != NULL);
00031 ReplicationOptions_descriptor_ = file->message_type(0);
00032 static const int ReplicationOptions_offsets_[1] = {
00033 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicationOptions, is_replicated_),
00034 };
00035 ReplicationOptions_reflection_ =
00036 new ::google::protobuf::internal::GeneratedMessageReflection(
00037 ReplicationOptions_descriptor_,
00038 ReplicationOptions::default_instance_,
00039 ReplicationOptions_offsets_,
00040 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicationOptions, _has_bits_[0]),
00041 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ReplicationOptions, _unknown_fields_),
00042 -1,
00043 ::google::protobuf::DescriptorPool::generated_pool(),
00044 ::google::protobuf::MessageFactory::generated_factory(),
00045 sizeof(ReplicationOptions));
00046 }
00047
00048 namespace {
00049
00050 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
00051 inline void protobuf_AssignDescriptorsOnce() {
00052 ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
00053 &protobuf_AssignDesc_replication_5foptions_2eproto);
00054 }
00055
00056 void protobuf_RegisterTypes(const ::std::string&) {
00057 protobuf_AssignDescriptorsOnce();
00058 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00059 ReplicationOptions_descriptor_, &ReplicationOptions::default_instance());
00060 }
00061
00062 }
00063
00064 void protobuf_ShutdownFile_replication_5foptions_2eproto() {
00065 delete ReplicationOptions::default_instance_;
00066 delete ReplicationOptions_reflection_;
00067 }
00068
00069 void protobuf_AddDesc_replication_5foptions_2eproto() {
00070 static bool already_here = false;
00071 if (already_here) return;
00072 already_here = true;
00073 GOOGLE_PROTOBUF_VERIFY_VERSION;
00074
00075 ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
00076 "\n\031replication_options.proto\022\020drizzled.me"
00077 "ssage\"+\n\022ReplicationOptions\022\025\n\ris_replic"
00078 "ated\030\002 \001(\010B%\n\024org.drizzle.messagesB\013Repl"
00079 "icationH\001", 129);
00080 ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
00081 "replication_options.proto", &protobuf_RegisterTypes);
00082 ReplicationOptions::default_instance_ = new ReplicationOptions();
00083 ReplicationOptions::default_instance_->InitAsDefaultInstance();
00084 ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_replication_5foptions_2eproto);
00085 }
00086
00087
00088 struct StaticDescriptorInitializer_replication_5foptions_2eproto {
00089 StaticDescriptorInitializer_replication_5foptions_2eproto() {
00090 protobuf_AddDesc_replication_5foptions_2eproto();
00091 }
00092 } static_descriptor_initializer_replication_5foptions_2eproto_;
00093
00094
00095
00096
00097 #ifndef _MSC_VER
00098 const int ReplicationOptions::kIsReplicatedFieldNumber;
00099 #endif // !_MSC_VER
00100
00101 ReplicationOptions::ReplicationOptions()
00102 : ::google::protobuf::Message() {
00103 SharedCtor();
00104 }
00105
00106 void ReplicationOptions::InitAsDefaultInstance() {
00107 }
00108
00109 ReplicationOptions::ReplicationOptions(const ReplicationOptions& from)
00110 : ::google::protobuf::Message() {
00111 SharedCtor();
00112 MergeFrom(from);
00113 }
00114
00115 void ReplicationOptions::SharedCtor() {
00116 _cached_size_ = 0;
00117 is_replicated_ = false;
00118 ::memset(_has_bits_, 0, sizeof(_has_bits_));
00119 }
00120
00121 ReplicationOptions::~ReplicationOptions() {
00122 SharedDtor();
00123 }
00124
00125 void ReplicationOptions::SharedDtor() {
00126 if (this != default_instance_) {
00127 }
00128 }
00129
00130 void ReplicationOptions::SetCachedSize(int size) const {
00131 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00132 _cached_size_ = size;
00133 GOOGLE_SAFE_CONCURRENT_WRITES_END();
00134 }
00135 const ::google::protobuf::Descriptor* ReplicationOptions::descriptor() {
00136 protobuf_AssignDescriptorsOnce();
00137 return ReplicationOptions_descriptor_;
00138 }
00139
00140 const ReplicationOptions& ReplicationOptions::default_instance() {
00141 if (default_instance_ == NULL) protobuf_AddDesc_replication_5foptions_2eproto(); return *default_instance_;
00142 }
00143
00144 ReplicationOptions* ReplicationOptions::default_instance_ = NULL;
00145
00146 ReplicationOptions* ReplicationOptions::New() const {
00147 return new ReplicationOptions;
00148 }
00149
00150 void ReplicationOptions::Clear() {
00151 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00152 is_replicated_ = false;
00153 }
00154 ::memset(_has_bits_, 0, sizeof(_has_bits_));
00155 mutable_unknown_fields()->Clear();
00156 }
00157
00158 bool ReplicationOptions::MergePartialFromCodedStream(
00159 ::google::protobuf::io::CodedInputStream* input) {
00160 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
00161 ::google::protobuf::uint32 tag;
00162 while ((tag = input->ReadTag()) != 0) {
00163 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
00164
00165 case 2: {
00166 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00167 ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
00168 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
00169 bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
00170 input, &is_replicated_)));
00171 _set_bit(0);
00172 } else {
00173 goto handle_uninterpreted;
00174 }
00175 if (input->ExpectAtEnd()) return true;
00176 break;
00177 }
00178
00179 default: {
00180 handle_uninterpreted:
00181 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00182 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
00183 return true;
00184 }
00185 DO_(::google::protobuf::internal::WireFormat::SkipField(
00186 input, tag, mutable_unknown_fields()));
00187 break;
00188 }
00189 }
00190 }
00191 return true;
00192 #undef DO_
00193 }
00194
00195 void ReplicationOptions::SerializeWithCachedSizes(
00196 ::google::protobuf::io::CodedOutputStream* output) const {
00197
00198 if (_has_bit(0)) {
00199 ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->is_replicated(), output);
00200 }
00201
00202 if (!unknown_fields().empty()) {
00203 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
00204 unknown_fields(), output);
00205 }
00206 }
00207
00208 ::google::protobuf::uint8* ReplicationOptions::SerializeWithCachedSizesToArray(
00209 ::google::protobuf::uint8* target) const {
00210
00211 if (_has_bit(0)) {
00212 target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->is_replicated(), target);
00213 }
00214
00215 if (!unknown_fields().empty()) {
00216 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
00217 unknown_fields(), target);
00218 }
00219 return target;
00220 }
00221
00222 int ReplicationOptions::ByteSize() const {
00223 int total_size = 0;
00224
00225 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00226
00227 if (has_is_replicated()) {
00228 total_size += 1 + 1;
00229 }
00230
00231 }
00232 if (!unknown_fields().empty()) {
00233 total_size +=
00234 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
00235 unknown_fields());
00236 }
00237 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00238 _cached_size_ = total_size;
00239 GOOGLE_SAFE_CONCURRENT_WRITES_END();
00240 return total_size;
00241 }
00242
00243 void ReplicationOptions::MergeFrom(const ::google::protobuf::Message& from) {
00244 GOOGLE_CHECK_NE(&from, this);
00245 const ReplicationOptions* source =
00246 ::google::protobuf::internal::dynamic_cast_if_available<const ReplicationOptions*>(
00247 &from);
00248 if (source == NULL) {
00249 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
00250 } else {
00251 MergeFrom(*source);
00252 }
00253 }
00254
00255 void ReplicationOptions::MergeFrom(const ReplicationOptions& from) {
00256 GOOGLE_CHECK_NE(&from, this);
00257 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00258 if (from._has_bit(0)) {
00259 set_is_replicated(from.is_replicated());
00260 }
00261 }
00262 mutable_unknown_fields()->MergeFrom(from.unknown_fields());
00263 }
00264
00265 void ReplicationOptions::CopyFrom(const ::google::protobuf::Message& from) {
00266 if (&from == this) return;
00267 Clear();
00268 MergeFrom(from);
00269 }
00270
00271 void ReplicationOptions::CopyFrom(const ReplicationOptions& from) {
00272 if (&from == this) return;
00273 Clear();
00274 MergeFrom(from);
00275 }
00276
00277 bool ReplicationOptions::IsInitialized() const {
00278
00279 return true;
00280 }
00281
00282 void ReplicationOptions::Swap(ReplicationOptions* other) {
00283 if (other != this) {
00284 std::swap(is_replicated_, other->is_replicated_);
00285 std::swap(_has_bits_[0], other->_has_bits_[0]);
00286 _unknown_fields_.Swap(&other->_unknown_fields_);
00287 std::swap(_cached_size_, other->_cached_size_);
00288 }
00289 }
00290
00291 ::google::protobuf::Metadata ReplicationOptions::GetMetadata() const {
00292 protobuf_AssignDescriptorsOnce();
00293 ::google::protobuf::Metadata metadata;
00294 metadata.descriptor = ReplicationOptions_descriptor_;
00295 metadata.reflection = ReplicationOptions_reflection_;
00296 return metadata;
00297 }
00298
00299
00300
00301
00302 }
00303 }
00304
00305