From 1af9382e77ba1196b4f47500768b6a32ac9f09dd Mon Sep 17 00:00:00 2001 From: vng Date: Fri, 4 Nov 2011 16:37:10 +0300 Subject: [PATCH] Generate drawing rules code. --- indexer/drules_struct.pb.cc | 2217 +++++++++++++++++++++++++++++++++++ indexer/drules_struct.pb.h | 1649 ++++++++++++++++++++++++++ indexer/drules_struct.proto | 3 +- indexer/indexer.pro | 9 +- 4 files changed, 3875 insertions(+), 3 deletions(-) create mode 100644 indexer/drules_struct.pb.cc create mode 100644 indexer/drules_struct.pb.h diff --git a/indexer/drules_struct.pb.cc b/indexer/drules_struct.pb.cc new file mode 100644 index 0000000000..fe9e9ea58b --- /dev/null +++ b/indexer/drules_struct.pb.cc @@ -0,0 +1,2217 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! + +#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION +#include "drules_struct.pb.h" + +#include + +#include +#include +#include +// @@protoc_insertion_point(includes) + +void protobuf_ShutdownFile_drules_5fstruct_2eproto() { + delete ColorProto::default_instance_; + delete DashDotProto::default_instance_; + delete LineRuleProto::default_instance_; + delete AreaRuleProto::default_instance_; + delete SymbolRuleProto::default_instance_; + delete CaptionRuleProto::default_instance_; + delete CircleRuleProto::default_instance_; + delete DrawElementProto::default_instance_; + delete ClassifElementProto::default_instance_; + delete ContainerProto::default_instance_; +} + +void protobuf_AddDesc_drules_5fstruct_2eproto() { + static bool already_here = false; + if (already_here) return; + already_here = true; + GOOGLE_PROTOBUF_VERIFY_VERSION; + + ColorProto::default_instance_ = new ColorProto(); + DashDotProto::default_instance_ = new DashDotProto(); + LineRuleProto::default_instance_ = new LineRuleProto(); + AreaRuleProto::default_instance_ = new AreaRuleProto(); + SymbolRuleProto::default_instance_ = new SymbolRuleProto(); + CaptionRuleProto::default_instance_ = new CaptionRuleProto(); + CircleRuleProto::default_instance_ = new CircleRuleProto(); + DrawElementProto::default_instance_ = new DrawElementProto(); + ClassifElementProto::default_instance_ = new ClassifElementProto(); + ContainerProto::default_instance_ = new ContainerProto(); + ColorProto::default_instance_->InitAsDefaultInstance(); + DashDotProto::default_instance_->InitAsDefaultInstance(); + LineRuleProto::default_instance_->InitAsDefaultInstance(); + AreaRuleProto::default_instance_->InitAsDefaultInstance(); + SymbolRuleProto::default_instance_->InitAsDefaultInstance(); + CaptionRuleProto::default_instance_->InitAsDefaultInstance(); + CircleRuleProto::default_instance_->InitAsDefaultInstance(); + DrawElementProto::default_instance_->InitAsDefaultInstance(); + ClassifElementProto::default_instance_->InitAsDefaultInstance(); + ContainerProto::default_instance_->InitAsDefaultInstance(); + ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_drules_5fstruct_2eproto); +} + +// Force AddDescriptors() to be called at static initialization time. +struct StaticDescriptorInitializer_drules_5fstruct_2eproto { + StaticDescriptorInitializer_drules_5fstruct_2eproto() { + protobuf_AddDesc_drules_5fstruct_2eproto(); + } +} static_descriptor_initializer_drules_5fstruct_2eproto_; + + +// =================================================================== + +#ifndef _MSC_VER +const int ColorProto::kColorFieldNumber; +const int ColorProto::kOpacityFieldNumber; +#endif // !_MSC_VER + +ColorProto::ColorProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void ColorProto::InitAsDefaultInstance() { +} + +ColorProto::ColorProto(const ColorProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void ColorProto::SharedCtor() { + _cached_size_ = 0; + color_ = 0; + opacity_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ColorProto::~ColorProto() { + SharedDtor(); +} + +void ColorProto::SharedDtor() { + if (this != default_instance_) { + } +} + +void ColorProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ColorProto& ColorProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +ColorProto* ColorProto::default_instance_ = NULL; + +ColorProto* ColorProto::New() const { + return new ColorProto; +} + +void ColorProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + color_ = 0; + opacity_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool ColorProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int32 color = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &color_))); + set_has_color(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(16)) goto parse_opacity; + break; + } + + // optional int32 opacity = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_opacity: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &opacity_))); + set_has_opacity(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void ColorProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int32 color = 1; + if (has_color()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->color(), output); + } + + // optional int32 opacity = 2; + if (has_opacity()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->opacity(), output); + } + +} + +int ColorProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int32 color = 1; + if (has_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->color()); + } + + // optional int32 opacity = 2; + if (has_opacity()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->opacity()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ColorProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void ColorProto::MergeFrom(const ColorProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_color()) { + set_color(from.color()); + } + if (from.has_opacity()) { + set_opacity(from.opacity()); + } + } +} + +void ColorProto::CopyFrom(const ColorProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ColorProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void ColorProto::Swap(ColorProto* other) { + if (other != this) { + std::swap(color_, other->color_); + std::swap(opacity_, other->opacity_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ColorProto::GetTypeName() const { + return "ColorProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int DashDotProto::kDdFieldNumber; +#endif // !_MSC_VER + +DashDotProto::DashDotProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void DashDotProto::InitAsDefaultInstance() { +} + +DashDotProto::DashDotProto(const DashDotProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void DashDotProto::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +DashDotProto::~DashDotProto() { + SharedDtor(); +} + +void DashDotProto::SharedDtor() { + if (this != default_instance_) { + } +} + +void DashDotProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const DashDotProto& DashDotProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +DashDotProto* DashDotProto::default_instance_ = NULL; + +DashDotProto* DashDotProto::New() const { + return new DashDotProto; +} + +void DashDotProto::Clear() { + dd_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool DashDotProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated double dd = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_dd: + DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + 1, 9, input, this->mutable_dd()))); + } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) + == ::google::protobuf::internal::WireFormatLite:: + WIRETYPE_LENGTH_DELIMITED) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, this->mutable_dd()))); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(9)) goto parse_dd; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void DashDotProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated double dd = 1; + for (int i = 0; i < this->dd_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteDouble( + 1, this->dd(i), output); + } + +} + +int DashDotProto::ByteSize() const { + int total_size = 0; + + // repeated double dd = 1; + { + int data_size = 0; + data_size = 8 * this->dd_size(); + total_size += 1 * this->dd_size() + data_size; + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void DashDotProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void DashDotProto::MergeFrom(const DashDotProto& from) { + GOOGLE_CHECK_NE(&from, this); + dd_.MergeFrom(from.dd_); +} + +void DashDotProto::CopyFrom(const DashDotProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DashDotProto::IsInitialized() const { + + return true; +} + +void DashDotProto::Swap(DashDotProto* other) { + if (other != this) { + dd_.Swap(&other->dd_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string DashDotProto::GetTypeName() const { + return "DashDotProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int LineRuleProto::kWidthFieldNumber; +const int LineRuleProto::kColorFieldNumber; +const int LineRuleProto::kDashdotFieldNumber; +#endif // !_MSC_VER + +LineRuleProto::LineRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void LineRuleProto::InitAsDefaultInstance() { + color_ = const_cast< ::ColorProto*>(&::ColorProto::default_instance()); + dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance()); +} + +LineRuleProto::LineRuleProto(const LineRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void LineRuleProto::SharedCtor() { + _cached_size_ = 0; + width_ = 0; + color_ = NULL; + dashdot_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +LineRuleProto::~LineRuleProto() { + SharedDtor(); +} + +void LineRuleProto::SharedDtor() { + if (this != default_instance_) { + delete color_; + delete dashdot_; + } +} + +void LineRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const LineRuleProto& LineRuleProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +LineRuleProto* LineRuleProto::default_instance_ = NULL; + +LineRuleProto* LineRuleProto::New() const { + return new LineRuleProto; +} + +void LineRuleProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + width_ = 0; + if (has_color()) { + if (color_ != NULL) color_->::ColorProto::Clear(); + } + if (has_dashdot()) { + if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool LineRuleProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required double width = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &width_))); + set_has_width(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_color; + break; + } + + // required .ColorProto color = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_color: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_color())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_dashdot; + break; + } + + // optional .DashDotProto dashdot = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_dashdot: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_dashdot())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void LineRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required double width = 1; + if (has_width()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->width(), output); + } + + // required .ColorProto color = 2; + if (has_color()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->color(), output); + } + + // optional .DashDotProto dashdot = 3; + if (has_dashdot()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->dashdot(), output); + } + +} + +int LineRuleProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required double width = 1; + if (has_width()) { + total_size += 1 + 8; + } + + // required .ColorProto color = 2; + if (has_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->color()); + } + + // optional .DashDotProto dashdot = 3; + if (has_dashdot()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->dashdot()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void LineRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void LineRuleProto::MergeFrom(const LineRuleProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_width()) { + set_width(from.width()); + } + if (from.has_color()) { + mutable_color()->::ColorProto::MergeFrom(from.color()); + } + if (from.has_dashdot()) { + mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot()); + } + } +} + +void LineRuleProto::CopyFrom(const LineRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool LineRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_color()) { + if (!this->color().IsInitialized()) return false; + } + return true; +} + +void LineRuleProto::Swap(LineRuleProto* other) { + if (other != this) { + std::swap(width_, other->width_); + std::swap(color_, other->color_); + std::swap(dashdot_, other->dashdot_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string LineRuleProto::GetTypeName() const { + return "LineRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int AreaRuleProto::kColorFieldNumber; +const int AreaRuleProto::kBorderFieldNumber; +#endif // !_MSC_VER + +AreaRuleProto::AreaRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void AreaRuleProto::InitAsDefaultInstance() { + color_ = const_cast< ::ColorProto*>(&::ColorProto::default_instance()); + border_ = const_cast< ::LineRuleProto*>(&::LineRuleProto::default_instance()); +} + +AreaRuleProto::AreaRuleProto(const AreaRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void AreaRuleProto::SharedCtor() { + _cached_size_ = 0; + color_ = NULL; + border_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +AreaRuleProto::~AreaRuleProto() { + SharedDtor(); +} + +void AreaRuleProto::SharedDtor() { + if (this != default_instance_) { + delete color_; + delete border_; + } +} + +void AreaRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const AreaRuleProto& AreaRuleProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +AreaRuleProto* AreaRuleProto::default_instance_ = NULL; + +AreaRuleProto* AreaRuleProto::New() const { + return new AreaRuleProto; +} + +void AreaRuleProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_color()) { + if (color_ != NULL) color_->::ColorProto::Clear(); + } + if (has_border()) { + if (border_ != NULL) border_->::LineRuleProto::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool AreaRuleProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required .ColorProto color = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_color())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_border; + break; + } + + // optional .LineRuleProto border = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_border: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_border())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void AreaRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required .ColorProto color = 1; + if (has_color()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->color(), output); + } + + // optional .LineRuleProto border = 2; + if (has_border()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->border(), output); + } + +} + +int AreaRuleProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required .ColorProto color = 1; + if (has_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->color()); + } + + // optional .LineRuleProto border = 2; + if (has_border()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->border()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void AreaRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void AreaRuleProto::MergeFrom(const AreaRuleProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_color()) { + mutable_color()->::ColorProto::MergeFrom(from.color()); + } + if (from.has_border()) { + mutable_border()->::LineRuleProto::MergeFrom(from.border()); + } + } +} + +void AreaRuleProto::CopyFrom(const AreaRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool AreaRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_color()) { + if (!this->color().IsInitialized()) return false; + } + if (has_border()) { + if (!this->border().IsInitialized()) return false; + } + return true; +} + +void AreaRuleProto::Swap(AreaRuleProto* other) { + if (other != this) { + std::swap(color_, other->color_); + std::swap(border_, other->border_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string AreaRuleProto::GetTypeName() const { + return "AreaRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int SymbolRuleProto::kNameFieldNumber; +#endif // !_MSC_VER + +SymbolRuleProto::SymbolRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void SymbolRuleProto::InitAsDefaultInstance() { +} + +SymbolRuleProto::SymbolRuleProto(const SymbolRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void SymbolRuleProto::SharedCtor() { + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +SymbolRuleProto::~SymbolRuleProto() { + SharedDtor(); +} + +void SymbolRuleProto::SharedDtor() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + } +} + +void SymbolRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const SymbolRuleProto& SymbolRuleProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +SymbolRuleProto* SymbolRuleProto::default_instance_ = NULL; + +SymbolRuleProto* SymbolRuleProto::New() const { + return new SymbolRuleProto; +} + +void SymbolRuleProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool SymbolRuleProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void SymbolRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->name(), output); + } + +} + +int SymbolRuleProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void SymbolRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void SymbolRuleProto::MergeFrom(const SymbolRuleProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_name(from.name()); + } + } +} + +void SymbolRuleProto::CopyFrom(const SymbolRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool SymbolRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + return true; +} + +void SymbolRuleProto::Swap(SymbolRuleProto* other) { + if (other != this) { + std::swap(name_, other->name_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string SymbolRuleProto::GetTypeName() const { + return "SymbolRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CaptionRuleProto::kHeightFieldNumber; +const int CaptionRuleProto::kColorFieldNumber; +const int CaptionRuleProto::kStrokeColorFieldNumber; +#endif // !_MSC_VER + +CaptionRuleProto::CaptionRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void CaptionRuleProto::InitAsDefaultInstance() { + color_ = const_cast< ::ColorProto*>(&::ColorProto::default_instance()); + stroke_color_ = const_cast< ::ColorProto*>(&::ColorProto::default_instance()); +} + +CaptionRuleProto::CaptionRuleProto(const CaptionRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void CaptionRuleProto::SharedCtor() { + _cached_size_ = 0; + height_ = 0; + color_ = NULL; + stroke_color_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CaptionRuleProto::~CaptionRuleProto() { + SharedDtor(); +} + +void CaptionRuleProto::SharedDtor() { + if (this != default_instance_) { + delete color_; + delete stroke_color_; + } +} + +void CaptionRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const CaptionRuleProto& CaptionRuleProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +CaptionRuleProto* CaptionRuleProto::default_instance_ = NULL; + +CaptionRuleProto* CaptionRuleProto::New() const { + return new CaptionRuleProto; +} + +void CaptionRuleProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + height_ = 0; + if (has_color()) { + if (color_ != NULL) color_->::ColorProto::Clear(); + } + if (has_stroke_color()) { + if (stroke_color_ != NULL) stroke_color_->::ColorProto::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool CaptionRuleProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int32 height = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &height_))); + set_has_height(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_color; + break; + } + + // optional .ColorProto color = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_color: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_color())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_stroke_color; + break; + } + + // optional .ColorProto stroke_color = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_stroke_color: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_stroke_color())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void CaptionRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int32 height = 1; + if (has_height()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->height(), output); + } + + // optional .ColorProto color = 2; + if (has_color()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->color(), output); + } + + // optional .ColorProto stroke_color = 3; + if (has_stroke_color()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->stroke_color(), output); + } + +} + +int CaptionRuleProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int32 height = 1; + if (has_height()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->height()); + } + + // optional .ColorProto color = 2; + if (has_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->color()); + } + + // optional .ColorProto stroke_color = 3; + if (has_stroke_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->stroke_color()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CaptionRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void CaptionRuleProto::MergeFrom(const CaptionRuleProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_height()) { + set_height(from.height()); + } + if (from.has_color()) { + mutable_color()->::ColorProto::MergeFrom(from.color()); + } + if (from.has_stroke_color()) { + mutable_stroke_color()->::ColorProto::MergeFrom(from.stroke_color()); + } + } +} + +void CaptionRuleProto::CopyFrom(const CaptionRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CaptionRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + if (has_color()) { + if (!this->color().IsInitialized()) return false; + } + if (has_stroke_color()) { + if (!this->stroke_color().IsInitialized()) return false; + } + return true; +} + +void CaptionRuleProto::Swap(CaptionRuleProto* other) { + if (other != this) { + std::swap(height_, other->height_); + std::swap(color_, other->color_); + std::swap(stroke_color_, other->stroke_color_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string CaptionRuleProto::GetTypeName() const { + return "CaptionRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int CircleRuleProto::kRadFieldNumber; +const int CircleRuleProto::kColorFieldNumber; +const int CircleRuleProto::kBorderFieldNumber; +#endif // !_MSC_VER + +CircleRuleProto::CircleRuleProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void CircleRuleProto::InitAsDefaultInstance() { + color_ = const_cast< ::ColorProto*>(&::ColorProto::default_instance()); + border_ = const_cast< ::LineRuleProto*>(&::LineRuleProto::default_instance()); +} + +CircleRuleProto::CircleRuleProto(const CircleRuleProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void CircleRuleProto::SharedCtor() { + _cached_size_ = 0; + rad_ = 0; + color_ = NULL; + border_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +CircleRuleProto::~CircleRuleProto() { + SharedDtor(); +} + +void CircleRuleProto::SharedDtor() { + if (this != default_instance_) { + delete color_; + delete border_; + } +} + +void CircleRuleProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const CircleRuleProto& CircleRuleProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +CircleRuleProto* CircleRuleProto::default_instance_ = NULL; + +CircleRuleProto* CircleRuleProto::New() const { + return new CircleRuleProto; +} + +void CircleRuleProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + rad_ = 0; + if (has_color()) { + if (color_ != NULL) color_->::ColorProto::Clear(); + } + if (has_border()) { + if (border_ != NULL) border_->::LineRuleProto::Clear(); + } + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool CircleRuleProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required double rad = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &rad_))); + set_has_rad(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_color; + break; + } + + // required .ColorProto color = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_color: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_color())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(26)) goto parse_border; + break; + } + + // optional .LineRuleProto border = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_border: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_border())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void CircleRuleProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required double rad = 1; + if (has_rad()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->rad(), output); + } + + // required .ColorProto color = 2; + if (has_color()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->color(), output); + } + + // optional .LineRuleProto border = 3; + if (has_border()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->border(), output); + } + +} + +int CircleRuleProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required double rad = 1; + if (has_rad()) { + total_size += 1 + 8; + } + + // required .ColorProto color = 2; + if (has_color()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->color()); + } + + // optional .LineRuleProto border = 3; + if (has_border()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->border()); + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void CircleRuleProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void CircleRuleProto::MergeFrom(const CircleRuleProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_rad()) { + set_rad(from.rad()); + } + if (from.has_color()) { + mutable_color()->::ColorProto::MergeFrom(from.color()); + } + if (from.has_border()) { + mutable_border()->::LineRuleProto::MergeFrom(from.border()); + } + } +} + +void CircleRuleProto::CopyFrom(const CircleRuleProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool CircleRuleProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + if (has_color()) { + if (!this->color().IsInitialized()) return false; + } + if (has_border()) { + if (!this->border().IsInitialized()) return false; + } + return true; +} + +void CircleRuleProto::Swap(CircleRuleProto* other) { + if (other != this) { + std::swap(rad_, other->rad_); + std::swap(color_, other->color_); + std::swap(border_, other->border_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string CircleRuleProto::GetTypeName() const { + return "CircleRuleProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int DrawElementProto::kScaleFieldNumber; +const int DrawElementProto::kLinesFieldNumber; +const int DrawElementProto::kAreaFieldNumber; +const int DrawElementProto::kSymFieldNumber; +const int DrawElementProto::kCapFieldNumber; +const int DrawElementProto::kCirFieldNumber; +#endif // !_MSC_VER + +DrawElementProto::DrawElementProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void DrawElementProto::InitAsDefaultInstance() { + area_ = const_cast< ::AreaRuleProto*>(&::AreaRuleProto::default_instance()); + sym_ = const_cast< ::SymbolRuleProto*>(&::SymbolRuleProto::default_instance()); + cap_ = const_cast< ::CaptionRuleProto*>(&::CaptionRuleProto::default_instance()); + cir_ = const_cast< ::CircleRuleProto*>(&::CircleRuleProto::default_instance()); +} + +DrawElementProto::DrawElementProto(const DrawElementProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void DrawElementProto::SharedCtor() { + _cached_size_ = 0; + scale_ = 0; + area_ = NULL; + sym_ = NULL; + cap_ = NULL; + cir_ = NULL; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +DrawElementProto::~DrawElementProto() { + SharedDtor(); +} + +void DrawElementProto::SharedDtor() { + if (this != default_instance_) { + delete area_; + delete sym_; + delete cap_; + delete cir_; + } +} + +void DrawElementProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const DrawElementProto& DrawElementProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +DrawElementProto* DrawElementProto::default_instance_ = NULL; + +DrawElementProto* DrawElementProto::New() const { + return new DrawElementProto; +} + +void DrawElementProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + scale_ = 0; + if (has_area()) { + if (area_ != NULL) area_->::AreaRuleProto::Clear(); + } + if (has_sym()) { + if (sym_ != NULL) sym_->::SymbolRuleProto::Clear(); + } + if (has_cap()) { + if (cap_ != NULL) cap_->::CaptionRuleProto::Clear(); + } + if (has_cir()) { + if (cir_ != NULL) cir_->::CircleRuleProto::Clear(); + } + } + lines_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool DrawElementProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required int32 scale = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + ::google::protobuf::int32, ::google::protobuf::internal::WireFormatLite::TYPE_INT32>( + input, &scale_))); + set_has_scale(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_lines; + break; + } + + // repeated .LineRuleProto lines = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_lines: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_lines())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_lines; + if (input->ExpectTag(26)) goto parse_area; + break; + } + + // optional .AreaRuleProto area = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_area: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_area())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(34)) goto parse_sym; + break; + } + + // optional .SymbolRuleProto sym = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_sym: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_sym())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(42)) goto parse_cap; + break; + } + + // optional .CaptionRuleProto cap = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_cap: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_cap())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(50)) goto parse_cir; + break; + } + + // optional .CircleRuleProto cir = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_cir: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_cir())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void DrawElementProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required int32 scale = 1; + if (has_scale()) { + ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->scale(), output); + } + + // repeated .LineRuleProto lines = 2; + for (int i = 0; i < this->lines_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->lines(i), output); + } + + // optional .AreaRuleProto area = 3; + if (has_area()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 3, this->area(), output); + } + + // optional .SymbolRuleProto sym = 4; + if (has_sym()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 4, this->sym(), output); + } + + // optional .CaptionRuleProto cap = 5; + if (has_cap()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 5, this->cap(), output); + } + + // optional .CircleRuleProto cir = 6; + if (has_cir()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 6, this->cir(), output); + } + +} + +int DrawElementProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required int32 scale = 1; + if (has_scale()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::Int32Size( + this->scale()); + } + + // optional .AreaRuleProto area = 3; + if (has_area()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->area()); + } + + // optional .SymbolRuleProto sym = 4; + if (has_sym()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->sym()); + } + + // optional .CaptionRuleProto cap = 5; + if (has_cap()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->cap()); + } + + // optional .CircleRuleProto cir = 6; + if (has_cir()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->cir()); + } + + } + // repeated .LineRuleProto lines = 2; + total_size += 1 * this->lines_size(); + for (int i = 0; i < this->lines_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->lines(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void DrawElementProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void DrawElementProto::MergeFrom(const DrawElementProto& from) { + GOOGLE_CHECK_NE(&from, this); + lines_.MergeFrom(from.lines_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_scale()) { + set_scale(from.scale()); + } + if (from.has_area()) { + mutable_area()->::AreaRuleProto::MergeFrom(from.area()); + } + if (from.has_sym()) { + mutable_sym()->::SymbolRuleProto::MergeFrom(from.sym()); + } + if (from.has_cap()) { + mutable_cap()->::CaptionRuleProto::MergeFrom(from.cap()); + } + if (from.has_cir()) { + mutable_cir()->::CircleRuleProto::MergeFrom(from.cir()); + } + } +} + +void DrawElementProto::CopyFrom(const DrawElementProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool DrawElementProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + for (int i = 0; i < lines_size(); i++) { + if (!this->lines(i).IsInitialized()) return false; + } + if (has_area()) { + if (!this->area().IsInitialized()) return false; + } + if (has_sym()) { + if (!this->sym().IsInitialized()) return false; + } + if (has_cap()) { + if (!this->cap().IsInitialized()) return false; + } + if (has_cir()) { + if (!this->cir().IsInitialized()) return false; + } + return true; +} + +void DrawElementProto::Swap(DrawElementProto* other) { + if (other != this) { + std::swap(scale_, other->scale_); + lines_.Swap(&other->lines_); + std::swap(area_, other->area_); + std::swap(sym_, other->sym_); + std::swap(cap_, other->cap_); + std::swap(cir_, other->cir_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string DrawElementProto::GetTypeName() const { + return "DrawElementProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ClassifElementProto::kNameFieldNumber; +const int ClassifElementProto::kLinesFieldNumber; +#endif // !_MSC_VER + +ClassifElementProto::ClassifElementProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void ClassifElementProto::InitAsDefaultInstance() { +} + +ClassifElementProto::ClassifElementProto(const ClassifElementProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void ClassifElementProto::SharedCtor() { + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ClassifElementProto::~ClassifElementProto() { + SharedDtor(); +} + +void ClassifElementProto::SharedDtor() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + } +} + +void ClassifElementProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ClassifElementProto& ClassifElementProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +ClassifElementProto* ClassifElementProto::default_instance_ = NULL; + +ClassifElementProto* ClassifElementProto::New() const { + return new ClassifElementProto; +} + +void ClassifElementProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + } + lines_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool ClassifElementProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // required string name = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + DO_(::google::protobuf::internal::WireFormatLite::ReadString( + input, this->mutable_name())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_lines; + break; + } + + // repeated .DrawElementProto lines = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_lines: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_lines())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(18)) goto parse_lines; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void ClassifElementProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->name(), output); + } + + // repeated .DrawElementProto lines = 2; + for (int i = 0; i < this->lines_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 2, this->lines(i), output); + } + +} + +int ClassifElementProto::ByteSize() const { + int total_size = 0; + + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + // required string name = 1; + if (has_name()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::StringSize( + this->name()); + } + + } + // repeated .DrawElementProto lines = 2; + total_size += 1 * this->lines_size(); + for (int i = 0; i < this->lines_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->lines(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ClassifElementProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void ClassifElementProto::MergeFrom(const ClassifElementProto& from) { + GOOGLE_CHECK_NE(&from, this); + lines_.MergeFrom(from.lines_); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_name(from.name()); + } + } +} + +void ClassifElementProto::CopyFrom(const ClassifElementProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ClassifElementProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; + + for (int i = 0; i < lines_size(); i++) { + if (!this->lines(i).IsInitialized()) return false; + } + return true; +} + +void ClassifElementProto::Swap(ClassifElementProto* other) { + if (other != this) { + std::swap(name_, other->name_); + lines_.Swap(&other->lines_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ClassifElementProto::GetTypeName() const { + return "ClassifElementProto"; +} + + +// =================================================================== + +#ifndef _MSC_VER +const int ContainerProto::kContFieldNumber; +#endif // !_MSC_VER + +ContainerProto::ContainerProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void ContainerProto::InitAsDefaultInstance() { +} + +ContainerProto::ContainerProto(const ContainerProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void ContainerProto::SharedCtor() { + _cached_size_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +ContainerProto::~ContainerProto() { + SharedDtor(); +} + +void ContainerProto::SharedDtor() { + if (this != default_instance_) { + } +} + +void ContainerProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ContainerProto& ContainerProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +ContainerProto* ContainerProto::default_instance_ = NULL; + +ContainerProto* ContainerProto::New() const { + return new ContainerProto; +} + +void ContainerProto::Clear() { + cont_.Clear(); + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool ContainerProto::MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input) { +#define DO_(EXPRESSION) if (!(EXPRESSION)) return false + ::google::protobuf::uint32 tag; + while ((tag = input->ReadTag()) != 0) { + switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) { + // repeated .ClassifElementProto cont = 1; + case 1: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_cont: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, add_cont())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(10)) goto parse_cont; + if (input->ExpectAtEnd()) return true; + break; + } + + default: { + handle_uninterpreted: + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) { + return true; + } + DO_(::google::protobuf::internal::WireFormatLite::SkipField(input, tag)); + break; + } + } + } + return true; +#undef DO_ +} + +void ContainerProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // repeated .ClassifElementProto cont = 1; + for (int i = 0; i < this->cont_size(); i++) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 1, this->cont(i), output); + } + +} + +int ContainerProto::ByteSize() const { + int total_size = 0; + + // repeated .ClassifElementProto cont = 1; + total_size += 1 * this->cont_size(); + for (int i = 0; i < this->cont_size(); i++) { + total_size += + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->cont(i)); + } + + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void ContainerProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void ContainerProto::MergeFrom(const ContainerProto& from) { + GOOGLE_CHECK_NE(&from, this); + cont_.MergeFrom(from.cont_); +} + +void ContainerProto::CopyFrom(const ContainerProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool ContainerProto::IsInitialized() const { + + for (int i = 0; i < cont_size(); i++) { + if (!this->cont(i).IsInitialized()) return false; + } + return true; +} + +void ContainerProto::Swap(ContainerProto* other) { + if (other != this) { + cont_.Swap(&other->cont_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string ContainerProto::GetTypeName() const { + return "ContainerProto"; +} + + +// @@protoc_insertion_point(namespace_scope) + +// @@protoc_insertion_point(global_scope) diff --git a/indexer/drules_struct.pb.h b/indexer/drules_struct.pb.h new file mode 100644 index 0000000000..c342e371ce --- /dev/null +++ b/indexer/drules_struct.pb.h @@ -0,0 +1,1649 @@ +// Generated by the protocol buffer compiler. DO NOT EDIT! +// source: drules_struct.proto + +#ifndef PROTOBUF_drules_5fstruct_2eproto__INCLUDED +#define PROTOBUF_drules_5fstruct_2eproto__INCLUDED + +#include + +#include + +#if GOOGLE_PROTOBUF_VERSION < 2004000 +#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 2004001 < 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 +#include +#include +// @@protoc_insertion_point(includes) + +// Internal implementation detail -- do not call these. +void protobuf_AddDesc_drules_5fstruct_2eproto(); +void protobuf_AssignDesc_drules_5fstruct_2eproto(); +void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + +class ColorProto; +class DashDotProto; +class LineRuleProto; +class AreaRuleProto; +class SymbolRuleProto; +class CaptionRuleProto; +class CircleRuleProto; +class DrawElementProto; +class ClassifElementProto; +class ContainerProto; + +// =================================================================== + +class ColorProto : public ::google::protobuf::MessageLite { + public: + ColorProto(); + virtual ~ColorProto(); + + ColorProto(const ColorProto& from); + + inline ColorProto& operator=(const ColorProto& from) { + CopyFrom(from); + return *this; + } + + static const ColorProto& default_instance(); + + void Swap(ColorProto* other); + + // implements Message ---------------------------------------------- + + ColorProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ColorProto& from); + void MergeFrom(const ColorProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int32 color = 1; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 1; + inline ::google::protobuf::int32 color() const; + inline void set_color(::google::protobuf::int32 value); + + // optional int32 opacity = 2; + inline bool has_opacity() const; + inline void clear_opacity(); + static const int kOpacityFieldNumber = 2; + inline ::google::protobuf::int32 opacity() const; + inline void set_opacity(::google::protobuf::int32 value); + + // @@protoc_insertion_point(class_scope:ColorProto) + private: + inline void set_has_color(); + inline void clear_has_color(); + inline void set_has_opacity(); + inline void clear_has_opacity(); + + ::google::protobuf::int32 color_; + ::google::protobuf::int32 opacity_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static ColorProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class DashDotProto : public ::google::protobuf::MessageLite { + public: + DashDotProto(); + virtual ~DashDotProto(); + + DashDotProto(const DashDotProto& from); + + inline DashDotProto& operator=(const DashDotProto& from) { + CopyFrom(from); + return *this; + } + + static const DashDotProto& default_instance(); + + void Swap(DashDotProto* other); + + // implements Message ---------------------------------------------- + + DashDotProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const DashDotProto& from); + void MergeFrom(const DashDotProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated double dd = 1; + inline int dd_size() const; + inline void clear_dd(); + static const int kDdFieldNumber = 1; + inline double dd(int index) const; + inline void set_dd(int index, double value); + inline void add_dd(double value); + inline const ::google::protobuf::RepeatedField< double >& + dd() const; + inline ::google::protobuf::RepeatedField< double >* + mutable_dd(); + + // @@protoc_insertion_point(class_scope:DashDotProto) + private: + + ::google::protobuf::RepeatedField< double > dd_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static DashDotProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class LineRuleProto : public ::google::protobuf::MessageLite { + public: + LineRuleProto(); + virtual ~LineRuleProto(); + + LineRuleProto(const LineRuleProto& from); + + inline LineRuleProto& operator=(const LineRuleProto& from) { + CopyFrom(from); + return *this; + } + + static const LineRuleProto& default_instance(); + + void Swap(LineRuleProto* other); + + // implements Message ---------------------------------------------- + + LineRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const LineRuleProto& from); + void MergeFrom(const LineRuleProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required double width = 1; + inline bool has_width() const; + inline void clear_width(); + static const int kWidthFieldNumber = 1; + inline double width() const; + inline void set_width(double value); + + // required .ColorProto color = 2; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 2; + inline const ::ColorProto& color() const; + inline ::ColorProto* mutable_color(); + inline ::ColorProto* release_color(); + + // optional .DashDotProto dashdot = 3; + inline bool has_dashdot() const; + inline void clear_dashdot(); + static const int kDashdotFieldNumber = 3; + inline const ::DashDotProto& dashdot() const; + inline ::DashDotProto* mutable_dashdot(); + inline ::DashDotProto* release_dashdot(); + + // @@protoc_insertion_point(class_scope:LineRuleProto) + private: + inline void set_has_width(); + inline void clear_has_width(); + inline void set_has_color(); + inline void clear_has_color(); + inline void set_has_dashdot(); + inline void clear_has_dashdot(); + + double width_; + ::ColorProto* color_; + ::DashDotProto* dashdot_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static LineRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class AreaRuleProto : public ::google::protobuf::MessageLite { + public: + AreaRuleProto(); + virtual ~AreaRuleProto(); + + AreaRuleProto(const AreaRuleProto& from); + + inline AreaRuleProto& operator=(const AreaRuleProto& from) { + CopyFrom(from); + return *this; + } + + static const AreaRuleProto& default_instance(); + + void Swap(AreaRuleProto* other); + + // implements Message ---------------------------------------------- + + AreaRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const AreaRuleProto& from); + void MergeFrom(const AreaRuleProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required .ColorProto color = 1; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 1; + inline const ::ColorProto& color() const; + inline ::ColorProto* mutable_color(); + inline ::ColorProto* release_color(); + + // optional .LineRuleProto border = 2; + inline bool has_border() const; + inline void clear_border(); + static const int kBorderFieldNumber = 2; + inline const ::LineRuleProto& border() const; + inline ::LineRuleProto* mutable_border(); + inline ::LineRuleProto* release_border(); + + // @@protoc_insertion_point(class_scope:AreaRuleProto) + private: + inline void set_has_color(); + inline void clear_has_color(); + inline void set_has_border(); + inline void clear_has_border(); + + ::ColorProto* color_; + ::LineRuleProto* border_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static AreaRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class SymbolRuleProto : public ::google::protobuf::MessageLite { + public: + SymbolRuleProto(); + virtual ~SymbolRuleProto(); + + SymbolRuleProto(const SymbolRuleProto& from); + + inline SymbolRuleProto& operator=(const SymbolRuleProto& from) { + CopyFrom(from); + return *this; + } + + static const SymbolRuleProto& default_instance(); + + void Swap(SymbolRuleProto* other); + + // implements Message ---------------------------------------------- + + SymbolRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const SymbolRuleProto& from); + void MergeFrom(const SymbolRuleProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string name = 1; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 1; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + + // @@protoc_insertion_point(class_scope:SymbolRuleProto) + private: + inline void set_has_name(); + inline void clear_has_name(); + + ::std::string* name_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static SymbolRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class CaptionRuleProto : public ::google::protobuf::MessageLite { + public: + CaptionRuleProto(); + virtual ~CaptionRuleProto(); + + CaptionRuleProto(const CaptionRuleProto& from); + + inline CaptionRuleProto& operator=(const CaptionRuleProto& from) { + CopyFrom(from); + return *this; + } + + static const CaptionRuleProto& default_instance(); + + void Swap(CaptionRuleProto* other); + + // implements Message ---------------------------------------------- + + CaptionRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const CaptionRuleProto& from); + void MergeFrom(const CaptionRuleProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int32 height = 1; + inline bool has_height() const; + inline void clear_height(); + static const int kHeightFieldNumber = 1; + inline ::google::protobuf::int32 height() const; + inline void set_height(::google::protobuf::int32 value); + + // optional .ColorProto color = 2; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 2; + inline const ::ColorProto& color() const; + inline ::ColorProto* mutable_color(); + inline ::ColorProto* release_color(); + + // optional .ColorProto stroke_color = 3; + inline bool has_stroke_color() const; + inline void clear_stroke_color(); + static const int kStrokeColorFieldNumber = 3; + inline const ::ColorProto& stroke_color() const; + inline ::ColorProto* mutable_stroke_color(); + inline ::ColorProto* release_stroke_color(); + + // @@protoc_insertion_point(class_scope:CaptionRuleProto) + private: + inline void set_has_height(); + inline void clear_has_height(); + inline void set_has_color(); + inline void clear_has_color(); + inline void set_has_stroke_color(); + inline void clear_has_stroke_color(); + + ::ColorProto* color_; + ::ColorProto* stroke_color_; + ::google::protobuf::int32 height_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static CaptionRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class CircleRuleProto : public ::google::protobuf::MessageLite { + public: + CircleRuleProto(); + virtual ~CircleRuleProto(); + + CircleRuleProto(const CircleRuleProto& from); + + inline CircleRuleProto& operator=(const CircleRuleProto& from) { + CopyFrom(from); + return *this; + } + + static const CircleRuleProto& default_instance(); + + void Swap(CircleRuleProto* other); + + // implements Message ---------------------------------------------- + + CircleRuleProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const CircleRuleProto& from); + void MergeFrom(const CircleRuleProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required double rad = 1; + inline bool has_rad() const; + inline void clear_rad(); + static const int kRadFieldNumber = 1; + inline double rad() const; + inline void set_rad(double value); + + // required .ColorProto color = 2; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 2; + inline const ::ColorProto& color() const; + inline ::ColorProto* mutable_color(); + inline ::ColorProto* release_color(); + + // optional .LineRuleProto border = 3; + inline bool has_border() const; + inline void clear_border(); + static const int kBorderFieldNumber = 3; + inline const ::LineRuleProto& border() const; + inline ::LineRuleProto* mutable_border(); + inline ::LineRuleProto* release_border(); + + // @@protoc_insertion_point(class_scope:CircleRuleProto) + private: + inline void set_has_rad(); + inline void clear_has_rad(); + inline void set_has_color(); + inline void clear_has_color(); + inline void set_has_border(); + inline void clear_has_border(); + + double rad_; + ::ColorProto* color_; + ::LineRuleProto* border_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static CircleRuleProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class DrawElementProto : public ::google::protobuf::MessageLite { + public: + DrawElementProto(); + virtual ~DrawElementProto(); + + DrawElementProto(const DrawElementProto& from); + + inline DrawElementProto& operator=(const DrawElementProto& from) { + CopyFrom(from); + return *this; + } + + static const DrawElementProto& default_instance(); + + void Swap(DrawElementProto* other); + + // implements Message ---------------------------------------------- + + DrawElementProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const DrawElementProto& from); + void MergeFrom(const DrawElementProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required int32 scale = 1; + inline bool has_scale() const; + inline void clear_scale(); + static const int kScaleFieldNumber = 1; + inline ::google::protobuf::int32 scale() const; + inline void set_scale(::google::protobuf::int32 value); + + // repeated .LineRuleProto lines = 2; + inline int lines_size() const; + inline void clear_lines(); + static const int kLinesFieldNumber = 2; + inline const ::LineRuleProto& lines(int index) const; + inline ::LineRuleProto* mutable_lines(int index); + inline ::LineRuleProto* add_lines(); + inline const ::google::protobuf::RepeatedPtrField< ::LineRuleProto >& + lines() const; + inline ::google::protobuf::RepeatedPtrField< ::LineRuleProto >* + mutable_lines(); + + // optional .AreaRuleProto area = 3; + inline bool has_area() const; + inline void clear_area(); + static const int kAreaFieldNumber = 3; + inline const ::AreaRuleProto& area() const; + inline ::AreaRuleProto* mutable_area(); + inline ::AreaRuleProto* release_area(); + + // optional .SymbolRuleProto sym = 4; + inline bool has_sym() const; + inline void clear_sym(); + static const int kSymFieldNumber = 4; + inline const ::SymbolRuleProto& sym() const; + inline ::SymbolRuleProto* mutable_sym(); + inline ::SymbolRuleProto* release_sym(); + + // optional .CaptionRuleProto cap = 5; + inline bool has_cap() const; + inline void clear_cap(); + static const int kCapFieldNumber = 5; + inline const ::CaptionRuleProto& cap() const; + inline ::CaptionRuleProto* mutable_cap(); + inline ::CaptionRuleProto* release_cap(); + + // optional .CircleRuleProto cir = 6; + inline bool has_cir() const; + inline void clear_cir(); + static const int kCirFieldNumber = 6; + inline const ::CircleRuleProto& cir() const; + inline ::CircleRuleProto* mutable_cir(); + inline ::CircleRuleProto* release_cir(); + + // @@protoc_insertion_point(class_scope:DrawElementProto) + private: + inline void set_has_scale(); + inline void clear_has_scale(); + inline void set_has_area(); + inline void clear_has_area(); + inline void set_has_sym(); + inline void clear_has_sym(); + inline void set_has_cap(); + inline void clear_has_cap(); + inline void set_has_cir(); + inline void clear_has_cir(); + + ::google::protobuf::RepeatedPtrField< ::LineRuleProto > lines_; + ::AreaRuleProto* area_; + ::SymbolRuleProto* sym_; + ::CaptionRuleProto* cap_; + ::CircleRuleProto* cir_; + ::google::protobuf::int32 scale_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static DrawElementProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class ClassifElementProto : public ::google::protobuf::MessageLite { + public: + ClassifElementProto(); + virtual ~ClassifElementProto(); + + ClassifElementProto(const ClassifElementProto& from); + + inline ClassifElementProto& operator=(const ClassifElementProto& from) { + CopyFrom(from); + return *this; + } + + static const ClassifElementProto& default_instance(); + + void Swap(ClassifElementProto* other); + + // implements Message ---------------------------------------------- + + ClassifElementProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ClassifElementProto& from); + void MergeFrom(const ClassifElementProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // required string name = 1; + inline bool has_name() const; + inline void clear_name(); + static const int kNameFieldNumber = 1; + inline const ::std::string& name() const; + inline void set_name(const ::std::string& value); + inline void set_name(const char* value); + inline void set_name(const char* value, size_t size); + inline ::std::string* mutable_name(); + inline ::std::string* release_name(); + + // repeated .DrawElementProto lines = 2; + inline int lines_size() const; + inline void clear_lines(); + static const int kLinesFieldNumber = 2; + inline const ::DrawElementProto& lines(int index) const; + inline ::DrawElementProto* mutable_lines(int index); + inline ::DrawElementProto* add_lines(); + inline const ::google::protobuf::RepeatedPtrField< ::DrawElementProto >& + lines() const; + inline ::google::protobuf::RepeatedPtrField< ::DrawElementProto >* + mutable_lines(); + + // @@protoc_insertion_point(class_scope:ClassifElementProto) + private: + inline void set_has_name(); + inline void clear_has_name(); + + ::std::string* name_; + ::google::protobuf::RepeatedPtrField< ::DrawElementProto > lines_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static ClassifElementProto* default_instance_; +}; +// ------------------------------------------------------------------- + +class ContainerProto : public ::google::protobuf::MessageLite { + public: + ContainerProto(); + virtual ~ContainerProto(); + + ContainerProto(const ContainerProto& from); + + inline ContainerProto& operator=(const ContainerProto& from) { + CopyFrom(from); + return *this; + } + + static const ContainerProto& default_instance(); + + void Swap(ContainerProto* other); + + // implements Message ---------------------------------------------- + + ContainerProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const ContainerProto& from); + void MergeFrom(const ContainerProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::std::string GetTypeName() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // repeated .ClassifElementProto cont = 1; + inline int cont_size() const; + inline void clear_cont(); + static const int kContFieldNumber = 1; + inline const ::ClassifElementProto& cont(int index) const; + inline ::ClassifElementProto* mutable_cont(int index); + inline ::ClassifElementProto* add_cont(); + inline const ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >& + cont() const; + inline ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >* + mutable_cont(); + + // @@protoc_insertion_point(class_scope:ContainerProto) + private: + + ::google::protobuf::RepeatedPtrField< ::ClassifElementProto > cont_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32]; + + friend void protobuf_AddDesc_drules_5fstruct_2eproto(); + friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); + friend void protobuf_ShutdownFile_drules_5fstruct_2eproto(); + + void InitAsDefaultInstance(); + static ContainerProto* default_instance_; +}; +// =================================================================== + + +// =================================================================== + +// ColorProto + +// required int32 color = 1; +inline bool ColorProto::has_color() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ColorProto::set_has_color() { + _has_bits_[0] |= 0x00000001u; +} +inline void ColorProto::clear_has_color() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ColorProto::clear_color() { + color_ = 0; + clear_has_color(); +} +inline ::google::protobuf::int32 ColorProto::color() const { + return color_; +} +inline void ColorProto::set_color(::google::protobuf::int32 value) { + set_has_color(); + color_ = value; +} + +// optional int32 opacity = 2; +inline bool ColorProto::has_opacity() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void ColorProto::set_has_opacity() { + _has_bits_[0] |= 0x00000002u; +} +inline void ColorProto::clear_has_opacity() { + _has_bits_[0] &= ~0x00000002u; +} +inline void ColorProto::clear_opacity() { + opacity_ = 0; + clear_has_opacity(); +} +inline ::google::protobuf::int32 ColorProto::opacity() const { + return opacity_; +} +inline void ColorProto::set_opacity(::google::protobuf::int32 value) { + set_has_opacity(); + opacity_ = value; +} + +// ------------------------------------------------------------------- + +// DashDotProto + +// repeated double dd = 1; +inline int DashDotProto::dd_size() const { + return dd_.size(); +} +inline void DashDotProto::clear_dd() { + dd_.Clear(); +} +inline double DashDotProto::dd(int index) const { + return dd_.Get(index); +} +inline void DashDotProto::set_dd(int index, double value) { + dd_.Set(index, value); +} +inline void DashDotProto::add_dd(double value) { + dd_.Add(value); +} +inline const ::google::protobuf::RepeatedField< double >& +DashDotProto::dd() const { + return dd_; +} +inline ::google::protobuf::RepeatedField< double >* +DashDotProto::mutable_dd() { + return &dd_; +} + +// ------------------------------------------------------------------- + +// LineRuleProto + +// required double width = 1; +inline bool LineRuleProto::has_width() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void LineRuleProto::set_has_width() { + _has_bits_[0] |= 0x00000001u; +} +inline void LineRuleProto::clear_has_width() { + _has_bits_[0] &= ~0x00000001u; +} +inline void LineRuleProto::clear_width() { + width_ = 0; + clear_has_width(); +} +inline double LineRuleProto::width() const { + return width_; +} +inline void LineRuleProto::set_width(double value) { + set_has_width(); + width_ = value; +} + +// required .ColorProto color = 2; +inline bool LineRuleProto::has_color() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void LineRuleProto::set_has_color() { + _has_bits_[0] |= 0x00000002u; +} +inline void LineRuleProto::clear_has_color() { + _has_bits_[0] &= ~0x00000002u; +} +inline void LineRuleProto::clear_color() { + if (color_ != NULL) color_->::ColorProto::Clear(); + clear_has_color(); +} +inline const ::ColorProto& LineRuleProto::color() const { + return color_ != NULL ? *color_ : *default_instance_->color_; +} +inline ::ColorProto* LineRuleProto::mutable_color() { + set_has_color(); + if (color_ == NULL) color_ = new ::ColorProto; + return color_; +} +inline ::ColorProto* LineRuleProto::release_color() { + clear_has_color(); + ::ColorProto* temp = color_; + color_ = NULL; + return temp; +} + +// optional .DashDotProto dashdot = 3; +inline bool LineRuleProto::has_dashdot() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void LineRuleProto::set_has_dashdot() { + _has_bits_[0] |= 0x00000004u; +} +inline void LineRuleProto::clear_has_dashdot() { + _has_bits_[0] &= ~0x00000004u; +} +inline void LineRuleProto::clear_dashdot() { + if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear(); + clear_has_dashdot(); +} +inline const ::DashDotProto& LineRuleProto::dashdot() const { + return dashdot_ != NULL ? *dashdot_ : *default_instance_->dashdot_; +} +inline ::DashDotProto* LineRuleProto::mutable_dashdot() { + set_has_dashdot(); + if (dashdot_ == NULL) dashdot_ = new ::DashDotProto; + return dashdot_; +} +inline ::DashDotProto* LineRuleProto::release_dashdot() { + clear_has_dashdot(); + ::DashDotProto* temp = dashdot_; + dashdot_ = NULL; + return temp; +} + +// ------------------------------------------------------------------- + +// AreaRuleProto + +// required .ColorProto color = 1; +inline bool AreaRuleProto::has_color() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void AreaRuleProto::set_has_color() { + _has_bits_[0] |= 0x00000001u; +} +inline void AreaRuleProto::clear_has_color() { + _has_bits_[0] &= ~0x00000001u; +} +inline void AreaRuleProto::clear_color() { + if (color_ != NULL) color_->::ColorProto::Clear(); + clear_has_color(); +} +inline const ::ColorProto& AreaRuleProto::color() const { + return color_ != NULL ? *color_ : *default_instance_->color_; +} +inline ::ColorProto* AreaRuleProto::mutable_color() { + set_has_color(); + if (color_ == NULL) color_ = new ::ColorProto; + return color_; +} +inline ::ColorProto* AreaRuleProto::release_color() { + clear_has_color(); + ::ColorProto* temp = color_; + color_ = NULL; + return temp; +} + +// optional .LineRuleProto border = 2; +inline bool AreaRuleProto::has_border() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void AreaRuleProto::set_has_border() { + _has_bits_[0] |= 0x00000002u; +} +inline void AreaRuleProto::clear_has_border() { + _has_bits_[0] &= ~0x00000002u; +} +inline void AreaRuleProto::clear_border() { + if (border_ != NULL) border_->::LineRuleProto::Clear(); + clear_has_border(); +} +inline const ::LineRuleProto& AreaRuleProto::border() const { + return border_ != NULL ? *border_ : *default_instance_->border_; +} +inline ::LineRuleProto* AreaRuleProto::mutable_border() { + set_has_border(); + if (border_ == NULL) border_ = new ::LineRuleProto; + return border_; +} +inline ::LineRuleProto* AreaRuleProto::release_border() { + clear_has_border(); + ::LineRuleProto* temp = border_; + border_ = NULL; + return temp; +} + +// ------------------------------------------------------------------- + +// SymbolRuleProto + +// required string name = 1; +inline bool SymbolRuleProto::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void SymbolRuleProto::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void SymbolRuleProto::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void SymbolRuleProto::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& SymbolRuleProto::name() const { + return *name_; +} +inline void SymbolRuleProto::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void SymbolRuleProto::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void SymbolRuleProto::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* SymbolRuleProto::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* SymbolRuleProto::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} + +// ------------------------------------------------------------------- + +// CaptionRuleProto + +// required int32 height = 1; +inline bool CaptionRuleProto::has_height() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CaptionRuleProto::set_has_height() { + _has_bits_[0] |= 0x00000001u; +} +inline void CaptionRuleProto::clear_has_height() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CaptionRuleProto::clear_height() { + height_ = 0; + clear_has_height(); +} +inline ::google::protobuf::int32 CaptionRuleProto::height() const { + return height_; +} +inline void CaptionRuleProto::set_height(::google::protobuf::int32 value) { + set_has_height(); + height_ = value; +} + +// optional .ColorProto color = 2; +inline bool CaptionRuleProto::has_color() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void CaptionRuleProto::set_has_color() { + _has_bits_[0] |= 0x00000002u; +} +inline void CaptionRuleProto::clear_has_color() { + _has_bits_[0] &= ~0x00000002u; +} +inline void CaptionRuleProto::clear_color() { + if (color_ != NULL) color_->::ColorProto::Clear(); + clear_has_color(); +} +inline const ::ColorProto& CaptionRuleProto::color() const { + return color_ != NULL ? *color_ : *default_instance_->color_; +} +inline ::ColorProto* CaptionRuleProto::mutable_color() { + set_has_color(); + if (color_ == NULL) color_ = new ::ColorProto; + return color_; +} +inline ::ColorProto* CaptionRuleProto::release_color() { + clear_has_color(); + ::ColorProto* temp = color_; + color_ = NULL; + return temp; +} + +// optional .ColorProto stroke_color = 3; +inline bool CaptionRuleProto::has_stroke_color() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void CaptionRuleProto::set_has_stroke_color() { + _has_bits_[0] |= 0x00000004u; +} +inline void CaptionRuleProto::clear_has_stroke_color() { + _has_bits_[0] &= ~0x00000004u; +} +inline void CaptionRuleProto::clear_stroke_color() { + if (stroke_color_ != NULL) stroke_color_->::ColorProto::Clear(); + clear_has_stroke_color(); +} +inline const ::ColorProto& CaptionRuleProto::stroke_color() const { + return stroke_color_ != NULL ? *stroke_color_ : *default_instance_->stroke_color_; +} +inline ::ColorProto* CaptionRuleProto::mutable_stroke_color() { + set_has_stroke_color(); + if (stroke_color_ == NULL) stroke_color_ = new ::ColorProto; + return stroke_color_; +} +inline ::ColorProto* CaptionRuleProto::release_stroke_color() { + clear_has_stroke_color(); + ::ColorProto* temp = stroke_color_; + stroke_color_ = NULL; + return temp; +} + +// ------------------------------------------------------------------- + +// CircleRuleProto + +// required double rad = 1; +inline bool CircleRuleProto::has_rad() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void CircleRuleProto::set_has_rad() { + _has_bits_[0] |= 0x00000001u; +} +inline void CircleRuleProto::clear_has_rad() { + _has_bits_[0] &= ~0x00000001u; +} +inline void CircleRuleProto::clear_rad() { + rad_ = 0; + clear_has_rad(); +} +inline double CircleRuleProto::rad() const { + return rad_; +} +inline void CircleRuleProto::set_rad(double value) { + set_has_rad(); + rad_ = value; +} + +// required .ColorProto color = 2; +inline bool CircleRuleProto::has_color() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void CircleRuleProto::set_has_color() { + _has_bits_[0] |= 0x00000002u; +} +inline void CircleRuleProto::clear_has_color() { + _has_bits_[0] &= ~0x00000002u; +} +inline void CircleRuleProto::clear_color() { + if (color_ != NULL) color_->::ColorProto::Clear(); + clear_has_color(); +} +inline const ::ColorProto& CircleRuleProto::color() const { + return color_ != NULL ? *color_ : *default_instance_->color_; +} +inline ::ColorProto* CircleRuleProto::mutable_color() { + set_has_color(); + if (color_ == NULL) color_ = new ::ColorProto; + return color_; +} +inline ::ColorProto* CircleRuleProto::release_color() { + clear_has_color(); + ::ColorProto* temp = color_; + color_ = NULL; + return temp; +} + +// optional .LineRuleProto border = 3; +inline bool CircleRuleProto::has_border() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void CircleRuleProto::set_has_border() { + _has_bits_[0] |= 0x00000004u; +} +inline void CircleRuleProto::clear_has_border() { + _has_bits_[0] &= ~0x00000004u; +} +inline void CircleRuleProto::clear_border() { + if (border_ != NULL) border_->::LineRuleProto::Clear(); + clear_has_border(); +} +inline const ::LineRuleProto& CircleRuleProto::border() const { + return border_ != NULL ? *border_ : *default_instance_->border_; +} +inline ::LineRuleProto* CircleRuleProto::mutable_border() { + set_has_border(); + if (border_ == NULL) border_ = new ::LineRuleProto; + return border_; +} +inline ::LineRuleProto* CircleRuleProto::release_border() { + clear_has_border(); + ::LineRuleProto* temp = border_; + border_ = NULL; + return temp; +} + +// ------------------------------------------------------------------- + +// DrawElementProto + +// required int32 scale = 1; +inline bool DrawElementProto::has_scale() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void DrawElementProto::set_has_scale() { + _has_bits_[0] |= 0x00000001u; +} +inline void DrawElementProto::clear_has_scale() { + _has_bits_[0] &= ~0x00000001u; +} +inline void DrawElementProto::clear_scale() { + scale_ = 0; + clear_has_scale(); +} +inline ::google::protobuf::int32 DrawElementProto::scale() const { + return scale_; +} +inline void DrawElementProto::set_scale(::google::protobuf::int32 value) { + set_has_scale(); + scale_ = value; +} + +// repeated .LineRuleProto lines = 2; +inline int DrawElementProto::lines_size() const { + return lines_.size(); +} +inline void DrawElementProto::clear_lines() { + lines_.Clear(); +} +inline const ::LineRuleProto& DrawElementProto::lines(int index) const { + return lines_.Get(index); +} +inline ::LineRuleProto* DrawElementProto::mutable_lines(int index) { + return lines_.Mutable(index); +} +inline ::LineRuleProto* DrawElementProto::add_lines() { + return lines_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::LineRuleProto >& +DrawElementProto::lines() const { + return lines_; +} +inline ::google::protobuf::RepeatedPtrField< ::LineRuleProto >* +DrawElementProto::mutable_lines() { + return &lines_; +} + +// optional .AreaRuleProto area = 3; +inline bool DrawElementProto::has_area() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void DrawElementProto::set_has_area() { + _has_bits_[0] |= 0x00000004u; +} +inline void DrawElementProto::clear_has_area() { + _has_bits_[0] &= ~0x00000004u; +} +inline void DrawElementProto::clear_area() { + if (area_ != NULL) area_->::AreaRuleProto::Clear(); + clear_has_area(); +} +inline const ::AreaRuleProto& DrawElementProto::area() const { + return area_ != NULL ? *area_ : *default_instance_->area_; +} +inline ::AreaRuleProto* DrawElementProto::mutable_area() { + set_has_area(); + if (area_ == NULL) area_ = new ::AreaRuleProto; + return area_; +} +inline ::AreaRuleProto* DrawElementProto::release_area() { + clear_has_area(); + ::AreaRuleProto* temp = area_; + area_ = NULL; + return temp; +} + +// optional .SymbolRuleProto sym = 4; +inline bool DrawElementProto::has_sym() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void DrawElementProto::set_has_sym() { + _has_bits_[0] |= 0x00000008u; +} +inline void DrawElementProto::clear_has_sym() { + _has_bits_[0] &= ~0x00000008u; +} +inline void DrawElementProto::clear_sym() { + if (sym_ != NULL) sym_->::SymbolRuleProto::Clear(); + clear_has_sym(); +} +inline const ::SymbolRuleProto& DrawElementProto::sym() const { + return sym_ != NULL ? *sym_ : *default_instance_->sym_; +} +inline ::SymbolRuleProto* DrawElementProto::mutable_sym() { + set_has_sym(); + if (sym_ == NULL) sym_ = new ::SymbolRuleProto; + return sym_; +} +inline ::SymbolRuleProto* DrawElementProto::release_sym() { + clear_has_sym(); + ::SymbolRuleProto* temp = sym_; + sym_ = NULL; + return temp; +} + +// optional .CaptionRuleProto cap = 5; +inline bool DrawElementProto::has_cap() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void DrawElementProto::set_has_cap() { + _has_bits_[0] |= 0x00000010u; +} +inline void DrawElementProto::clear_has_cap() { + _has_bits_[0] &= ~0x00000010u; +} +inline void DrawElementProto::clear_cap() { + if (cap_ != NULL) cap_->::CaptionRuleProto::Clear(); + clear_has_cap(); +} +inline const ::CaptionRuleProto& DrawElementProto::cap() const { + return cap_ != NULL ? *cap_ : *default_instance_->cap_; +} +inline ::CaptionRuleProto* DrawElementProto::mutable_cap() { + set_has_cap(); + if (cap_ == NULL) cap_ = new ::CaptionRuleProto; + return cap_; +} +inline ::CaptionRuleProto* DrawElementProto::release_cap() { + clear_has_cap(); + ::CaptionRuleProto* temp = cap_; + cap_ = NULL; + return temp; +} + +// optional .CircleRuleProto cir = 6; +inline bool DrawElementProto::has_cir() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void DrawElementProto::set_has_cir() { + _has_bits_[0] |= 0x00000020u; +} +inline void DrawElementProto::clear_has_cir() { + _has_bits_[0] &= ~0x00000020u; +} +inline void DrawElementProto::clear_cir() { + if (cir_ != NULL) cir_->::CircleRuleProto::Clear(); + clear_has_cir(); +} +inline const ::CircleRuleProto& DrawElementProto::cir() const { + return cir_ != NULL ? *cir_ : *default_instance_->cir_; +} +inline ::CircleRuleProto* DrawElementProto::mutable_cir() { + set_has_cir(); + if (cir_ == NULL) cir_ = new ::CircleRuleProto; + return cir_; +} +inline ::CircleRuleProto* DrawElementProto::release_cir() { + clear_has_cir(); + ::CircleRuleProto* temp = cir_; + cir_ = NULL; + return temp; +} + +// ------------------------------------------------------------------- + +// ClassifElementProto + +// required string name = 1; +inline bool ClassifElementProto::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void ClassifElementProto::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void ClassifElementProto::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void ClassifElementProto::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& ClassifElementProto::name() const { + return *name_; +} +inline void ClassifElementProto::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void ClassifElementProto::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void ClassifElementProto::set_name(const char* value, size_t size) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(reinterpret_cast(value), size); +} +inline ::std::string* ClassifElementProto::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* ClassifElementProto::release_name() { + clear_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + return NULL; + } else { + ::std::string* temp = name_; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + return temp; + } +} + +// repeated .DrawElementProto lines = 2; +inline int ClassifElementProto::lines_size() const { + return lines_.size(); +} +inline void ClassifElementProto::clear_lines() { + lines_.Clear(); +} +inline const ::DrawElementProto& ClassifElementProto::lines(int index) const { + return lines_.Get(index); +} +inline ::DrawElementProto* ClassifElementProto::mutable_lines(int index) { + return lines_.Mutable(index); +} +inline ::DrawElementProto* ClassifElementProto::add_lines() { + return lines_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::DrawElementProto >& +ClassifElementProto::lines() const { + return lines_; +} +inline ::google::protobuf::RepeatedPtrField< ::DrawElementProto >* +ClassifElementProto::mutable_lines() { + return &lines_; +} + +// ------------------------------------------------------------------- + +// ContainerProto + +// repeated .ClassifElementProto cont = 1; +inline int ContainerProto::cont_size() const { + return cont_.size(); +} +inline void ContainerProto::clear_cont() { + cont_.Clear(); +} +inline const ::ClassifElementProto& ContainerProto::cont(int index) const { + return cont_.Get(index); +} +inline ::ClassifElementProto* ContainerProto::mutable_cont(int index) { + return cont_.Mutable(index); +} +inline ::ClassifElementProto* ContainerProto::add_cont() { + return cont_.Add(); +} +inline const ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >& +ContainerProto::cont() const { + return cont_; +} +inline ::google::protobuf::RepeatedPtrField< ::ClassifElementProto >* +ContainerProto::mutable_cont() { + return &cont_; +} + + +// @@protoc_insertion_point(namespace_scope) + +// @@protoc_insertion_point(global_scope) + +#endif // PROTOBUF_drules_5fstruct_2eproto__INCLUDED diff --git a/indexer/drules_struct.proto b/indexer/drules_struct.proto index 5352d84052..512617ec5f 100644 --- a/indexer/drules_struct.proto +++ b/indexer/drules_struct.proto @@ -1,8 +1,9 @@ +option optimize_for = LITE_RUNTIME; message ColorProto { required int32 color = 1; - optional int32 opacity = 2; // opacity : 0 - completly invisible, 255 - completly visible + optional int32 opacity = 2; // opacity : 0 - completely invisible, 255 - completely visible } message DashDotProto diff --git a/indexer/indexer.pro b/indexer/indexer.pro index 54150ad42c..beb4bbbf54 100644 --- a/indexer/indexer.pro +++ b/indexer/indexer.pro @@ -3,9 +3,10 @@ TARGET = indexer TEMPLATE = lib CONFIG += staticlib +INCLUDEPATH += ../3party/protobuf/src ROOT_DIR = .. -DEPENDENCIES = geometry coding base expat +DEPENDENCIES = geometry coding base expat protobuf include($$ROOT_DIR/common.pri) @@ -38,7 +39,8 @@ SOURCES += \ mwm_set.cpp \ index.cpp \ categories_holder.cpp \ - search_string_utils.cpp + search_string_utils.cpp \ + drules_struct.pb.cc \ HEADERS += \ feature.hpp \ @@ -85,3 +87,6 @@ HEADERS += \ search_delimiters.hpp \ mwm_set.hpp \ categories_holder.hpp \ + drules_struct.pb.h \ + +OTHER_FILES += drules_struct.proto