From ce69b03937cf0e6f8024ac1be2767a9ca194abf0 Mon Sep 17 00:00:00 2001 From: rachytski Date: Thu, 3 Jan 2013 15:43:00 +0300 Subject: [PATCH] added PenJoin, PenCap and PathSym into our protobuf format, into Pen::Info structure and wrote deserialization code. --- graphics/path_renderer.cpp | 44 +- graphics/path_renderer.hpp | 8 +- graphics/pen.cpp | 129 +-- graphics/pen.hpp | 31 +- indexer/drawing_rules.cpp | 6 + indexer/drules_struct.pb.cc | 735 +++++++++++++++- indexer/drules_struct.pb.h | 475 ++++++++++- indexer/drules_struct.proto | 25 + indexer/drules_struct_lite.pb.cc | 764 ++++++++++++++--- indexer/drules_struct_lite.pb.h | 1342 ++++++++++++++++++++---------- map/proto_to_styles.cpp | 40 +- 11 files changed, 2880 insertions(+), 719 deletions(-) diff --git a/graphics/path_renderer.cpp b/graphics/path_renderer.cpp index e293226711..d263c9b0e6 100644 --- a/graphics/path_renderer.cpp +++ b/graphics/path_renderer.cpp @@ -20,33 +20,45 @@ namespace graphics m_fastSolidPath(params.m_fastSolidPath) {} - void PathRenderer::drawPath(m2::PointD const * points, size_t pointsCount, double offset, uint32_t resID, double depth) + void PathRenderer::drawPath(m2::PointD const * pts, size_t ptsCount, double offset, uint32_t resID, double depth) { ++m_pathCount; - m_pointsCount += pointsCount; + m_pointsCount += ptsCount; if (!m_drawPathes) return; - ASSERT_GREATER_OR_EQUAL(pointsCount, 2, ()); + ASSERT_GREATER_OR_EQUAL(ptsCount, 2, ()); ASSERT_NOT_EQUAL(resID, uint32_t(-1), ()); - Resource const * res(base_t::fromID(resID)); + Resource const * res = base_t::fromID(resID); + if (res == 0) { - LOG(LINFO, ("drawPath: resID=", resID, " wasn't found on current skin")); + LOG(LINFO, ("drawPath: resID=", resID, "wasn't found on current skin")); return; } ASSERT(res->m_cat == Resource::EPen, ()); Pen const * pen = static_cast(res); - if (m_fastSolidPath && pen->m_isSolid) - { - drawFastSolidPath(points, pointsCount, resID, depth); - return; - } + if (!pen->m_info.m_symbol.empty()) + drawSymbolPath(pts, ptsCount, offset, pen, depth); + else + if (m_fastSolidPath && pen->m_isSolid) + drawSolidPath(pts, ptsCount, offset, pen, depth); + else + drawStipplePath(pts, ptsCount, offset, pen, depth); + } + + void PathRenderer::drawSymbolPath(m2::PointD const * pts, size_t ptsCount, double offset, Pen const * pen, double depth) + { + LOG(LINFO, ("drawSymbolPath is unimplemented. symbolName=", pen->m_info.m_symbol)); + } + + void PathRenderer::drawStipplePath(m2::PointD const * points, size_t pointsCount, double offset, Pen const * pen, double depth) + { float rawTileStartLen = 0; float rawTileLen = (float)pen->rawTileLen(); @@ -94,7 +106,7 @@ namespace graphics /// Length of the actual pattern data being tiling(without antialiasing zones). rawTileLen = 0; - GeometryPipeline & p = pipeline(res->m_pipelineID); + GeometryPipeline & p = pipeline(pen->m_pipelineID); shared_ptr texture = p.texture(); @@ -243,14 +255,8 @@ namespace graphics } } - void PathRenderer::drawFastSolidPath(m2::PointD const * points, size_t pointsCount, uint32_t resID, double depth) + void PathRenderer::drawSolidPath(m2::PointD const * points, size_t pointsCount, double offset, Pen const * pen, double depth) { - ASSERT_GREATER_OR_EQUAL(pointsCount, 2, ()); - Resource const * res(base_t::fromID(resID)); - - ASSERT(res->m_cat == Resource::EPen, ()); - Pen const * pen = static_cast(res); - ASSERT(pen->m_isSolid, ()); for (size_t i = 0; i < pointsCount - 1; ++i) @@ -289,7 +295,7 @@ namespace graphics nextPt + fDir - fNorm }; - GeometryPipeline & p = pipeline(res->m_pipelineID); + GeometryPipeline & p = pipeline(pen->m_pipelineID); shared_ptr texture = p.texture(); diff --git a/graphics/path_renderer.hpp b/graphics/path_renderer.hpp index aca2e70d08..60e85401ea 100644 --- a/graphics/path_renderer.hpp +++ b/graphics/path_renderer.hpp @@ -5,6 +5,8 @@ namespace graphics { + class Pen; + class PathRenderer : public AreaRenderer { private: @@ -14,7 +16,9 @@ namespace graphics bool m_drawPathes; bool m_fastSolidPath; - void drawFastSolidPath(m2::PointD const * points, size_t pointsCount, uint32_t resID, double depth); + void drawSolidPath(m2::PointD const * pts, size_t ptsCount, double offset, Pen const * pen, double depth); + void drawStipplePath(m2::PointD const * pts, size_t ptsCount, double offset, Pen const * pen, double depth); + void drawSymbolPath(m2::PointD const * pts, size_t ptsCount, double offset, Pen const * pen, double depth); public: @@ -29,7 +33,7 @@ namespace graphics PathRenderer(Params const & params); - void drawPath(m2::PointD const * points, size_t pointsCount, double offset, uint32_t resID, double depth); + void drawPath(m2::PointD const * pts, size_t ptsCount, double offset, uint32_t resID, double depth); void beginFrame(); void endFrame(); diff --git a/graphics/pen.cpp b/graphics/pen.cpp index d598d11094..531884be82 100644 --- a/graphics/pen.cpp +++ b/graphics/pen.cpp @@ -11,82 +11,95 @@ namespace graphics { - Pen::Info::Info() - : Resource::Info(EPen) - {} - Pen::Info::Info(Color const & color, double w, double const * pattern, size_t patternSize, - double offset) + double offset, + char const * symbol, + double step, + ELineJoin join, + ELineCap cap) : Resource::Info(EPen), m_color(color), m_w(w), m_offset(offset), + m_step(step), + m_join(join), + m_cap(cap), m_isSolid(false) { + if (symbol != 0) + m_symbol = string(symbol); + if (m_w < 1.0) m_w = 1.0; - /// if pattern is solid - if ((pattern == 0 ) || (patternSize == 0)) - m_isSolid = true; + if (!m_symbol.empty()) + { + m_isSolid = false; + } else { - buffer_vector tmpV; - copy(pattern, pattern + patternSize, back_inserter(tmpV)); - - if (tmpV.size() % 2) - tmpV.push_back(0); - - double length = 0; - - /// ensuring that a minimal element has a length of 2px - for (size_t i = 0; i < tmpV.size(); ++i) + /// if pattern is solid + if ((pattern == 0 ) || (patternSize == 0)) + m_isSolid = true; + else { - if ((tmpV[i] < 2) && (tmpV[i] > 0)) - tmpV[i] = 2; - length += tmpV[i]; - } + buffer_vector tmpV; + copy(pattern, pattern + patternSize, back_inserter(tmpV)); - int i = 0; + if (tmpV.size() % 2) + tmpV.push_back(0); - buffer_vector vec; + double length = 0; - if ((offset >= length) || (offset < 0)) - offset -= floor(offset / length) * length; - - double curLen = 0; - - /// shifting pattern - while (true) - { - if (curLen + tmpV[i] > offset) + /// ensuring that a minimal element has a length of 2px + for (size_t i = 0; i < tmpV.size(); ++i) { - //we're inside, let's split the pattern - - if (i % 2 == 1) - vec.push_back(0); - - vec.push_back(curLen + tmpV[i] - offset); - copy(tmpV.begin() + i + 1, tmpV.end(), back_inserter(vec)); - copy(tmpV.begin(), tmpV.begin() + i, back_inserter(vec)); - vec.push_back(offset - curLen); - - if (i % 2 == 0) - vec.push_back(0); - - break; + if ((tmpV[i] < 2) && (tmpV[i] > 0)) + tmpV[i] = 2; + length += tmpV[i]; } - else - curLen += tmpV[i++]; - } - int periods = max(int((256 - 4) / length), 1); - m_pat.reserve(periods * vec.size()); - for (int i = 0; i < periods; ++i) - copy(vec.begin(), vec.end(), back_inserter(m_pat)); + int i = 0; + + buffer_vector vec; + + if ((offset >= length) || (offset < 0)) + offset -= floor(offset / length) * length; + + double curLen = 0; + + /// shifting pattern + while (true) + { + if (curLen + tmpV[i] > offset) + { + //we're inside, let's split the pattern + + if (i % 2 == 1) + vec.push_back(0); + + vec.push_back(curLen + tmpV[i] - offset); + copy(tmpV.begin() + i + 1, tmpV.end(), back_inserter(vec)); + copy(tmpV.begin(), tmpV.begin() + i, back_inserter(vec)); + vec.push_back(offset - curLen); + + if (i % 2 == 0) + vec.push_back(0); + + break; + } + else + curLen += tmpV[i++]; + } + + int periods = max(int((256 - 4) / length), 1); + m_pat.reserve(periods * vec.size()); + for (int i = 0; i < periods; ++i) + copy(vec.begin(), vec.end(), back_inserter(m_pat)); + } } } @@ -158,6 +171,14 @@ namespace graphics for (size_t i = 0; i < m_pat.size(); ++i) if (m_pat[i] != rp->m_pat[i]) return m_pat[i] < rp->m_pat[i]; + if (m_join != rp->m_join) + return m_join < rp->m_join; + if (m_cap != rp->m_cap) + return m_cap < rp->m_cap; + if (m_symbol != rp->m_symbol) + return m_symbol < rp->m_symbol; + if (m_step != rp->m_step) + return m_step < rp->m_step; return false; } diff --git a/graphics/pen.hpp b/graphics/pen.hpp index 722b090fb4..7397cbe95d 100644 --- a/graphics/pen.hpp +++ b/graphics/pen.hpp @@ -15,20 +15,39 @@ namespace graphics /// used as a texture-cache-key struct Info : public Resource::Info { + enum ELineJoin + { + ERoundJoin, + EBevelJoin + }; + + enum ELineCap + { + ERoundCap, + EButtCap + }; + typedef buffer_vector TPattern; Color m_color; double m_w; TPattern m_pat; double m_offset; + string m_symbol; + double m_step; + ELineJoin m_join; + ELineCap m_cap; bool m_isSolid; - Info(); - Info(Color const & color, - double width, - double const * pattern, - size_t patternSize, - double offset); + Info(Color const & color = Color(0, 0, 0, 255), + double width = 1.0, + double const * pattern = 0, + size_t patternSize = 0, + double offset = 0, + char const * symbol = 0, + double step = 0, + ELineJoin join = ERoundJoin, + ELineCap cap = ERoundCap); double firstDashOffset() const; bool atDashOffset(double offset) const; diff --git a/indexer/drawing_rules.cpp b/indexer/drawing_rules.cpp index 7c7050c340..b381f5ca12 100644 --- a/indexer/drawing_rules.cpp +++ b/indexer/drawing_rules.cpp @@ -184,6 +184,12 @@ namespace m_line.set_width(r.width()); if (r.has_dashdot()) *(m_line.mutable_dashdot()) = r.dashdot(); + if (r.has_pathsym()) + *(m_line.mutable_pathsym()) = r.pathsym(); + if (r.has_join()) + m_line.set_join(r.join()); + if (r.has_cap()) + m_line.set_cap(r.cap()); } virtual LineDefProto const * GetLine() const { return &m_line; } diff --git a/indexer/drules_struct.pb.cc b/indexer/drules_struct.pb.cc index 268c04ecc2..3d68a88ccd 100644 --- a/indexer/drules_struct.pb.cc +++ b/indexer/drules_struct.pb.cc @@ -18,6 +18,9 @@ namespace { const ::google::protobuf::Descriptor* DashDotProto_descriptor_ = NULL; const ::google::protobuf::internal::GeneratedMessageReflection* DashDotProto_reflection_ = NULL; +const ::google::protobuf::Descriptor* PathSymProto_descriptor_ = NULL; +const ::google::protobuf::internal::GeneratedMessageReflection* + PathSymProto_reflection_ = NULL; const ::google::protobuf::Descriptor* LineRuleProto_descriptor_ = NULL; const ::google::protobuf::internal::GeneratedMessageReflection* LineRuleProto_reflection_ = NULL; @@ -51,6 +54,8 @@ const ::google::protobuf::internal::GeneratedMessageReflection* const ::google::protobuf::Descriptor* ContainerProto_descriptor_ = NULL; const ::google::protobuf::internal::GeneratedMessageReflection* ContainerProto_reflection_ = NULL; +const ::google::protobuf::EnumDescriptor* LineJoin_descriptor_ = NULL; +const ::google::protobuf::EnumDescriptor* LineCap_descriptor_ = NULL; } // namespace @@ -77,12 +82,32 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(DashDotProto)); - LineRuleProto_descriptor_ = file->message_type(1); - static const int LineRuleProto_offsets_[4] = { + PathSymProto_descriptor_ = file->message_type(1); + static const int PathSymProto_offsets_[3] = { + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, name_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, step_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, offset_), + }; + PathSymProto_reflection_ = + new ::google::protobuf::internal::GeneratedMessageReflection( + PathSymProto_descriptor_, + PathSymProto::default_instance_, + PathSymProto_offsets_, + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, _has_bits_[0]), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathSymProto, _unknown_fields_), + -1, + ::google::protobuf::DescriptorPool::generated_pool(), + ::google::protobuf::MessageFactory::generated_factory(), + sizeof(PathSymProto)); + LineRuleProto_descriptor_ = file->message_type(2); + static const int LineRuleProto_offsets_[7] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, width_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, color_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, dashdot_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, priority_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, pathsym_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, join_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineRuleProto, cap_), }; LineRuleProto_reflection_ = new ::google::protobuf::internal::GeneratedMessageReflection( @@ -95,11 +120,14 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(LineRuleProto)); - LineDefProto_descriptor_ = file->message_type(2); - static const int LineDefProto_offsets_[3] = { + LineDefProto_descriptor_ = file->message_type(3); + static const int LineDefProto_offsets_[6] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, width_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, color_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, dashdot_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, pathsym_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, join_), + GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(LineDefProto, cap_), }; LineDefProto_reflection_ = new ::google::protobuf::internal::GeneratedMessageReflection( @@ -112,7 +140,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(LineDefProto)); - AreaRuleProto_descriptor_ = file->message_type(3); + AreaRuleProto_descriptor_ = file->message_type(4); static const int AreaRuleProto_offsets_[3] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AreaRuleProto, color_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AreaRuleProto, border_), @@ -129,7 +157,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(AreaRuleProto)); - SymbolRuleProto_descriptor_ = file->message_type(4); + SymbolRuleProto_descriptor_ = file->message_type(5); static const int SymbolRuleProto_offsets_[3] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SymbolRuleProto, name_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SymbolRuleProto, apply_for_type_), @@ -146,7 +174,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(SymbolRuleProto)); - CaptionDefProto_descriptor_ = file->message_type(5); + CaptionDefProto_descriptor_ = file->message_type(6); static const int CaptionDefProto_offsets_[3] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, height_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionDefProto, color_), @@ -163,7 +191,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(CaptionDefProto)); - CaptionRuleProto_descriptor_ = file->message_type(6); + CaptionRuleProto_descriptor_ = file->message_type(7); static const int CaptionRuleProto_offsets_[3] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionRuleProto, primary_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CaptionRuleProto, secondary_), @@ -180,7 +208,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(CaptionRuleProto)); - CircleRuleProto_descriptor_ = file->message_type(7); + CircleRuleProto_descriptor_ = file->message_type(8); static const int CircleRuleProto_offsets_[4] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CircleRuleProto, radius_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CircleRuleProto, color_), @@ -198,7 +226,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(CircleRuleProto)); - PathTextRuleProto_descriptor_ = file->message_type(8); + PathTextRuleProto_descriptor_ = file->message_type(9); static const int PathTextRuleProto_offsets_[3] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathTextRuleProto, primary_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(PathTextRuleProto, secondary_), @@ -215,7 +243,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(PathTextRuleProto)); - DrawElementProto_descriptor_ = file->message_type(9); + DrawElementProto_descriptor_ = file->message_type(10); static const int DrawElementProto_offsets_[7] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, scale_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DrawElementProto, lines_), @@ -236,7 +264,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(DrawElementProto)); - ClassifElementProto_descriptor_ = file->message_type(10); + ClassifElementProto_descriptor_ = file->message_type(11); static const int ClassifElementProto_offsets_[2] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClassifElementProto, name_), GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ClassifElementProto, element_), @@ -252,7 +280,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(ClassifElementProto)); - ContainerProto_descriptor_ = file->message_type(11); + ContainerProto_descriptor_ = file->message_type(12); static const int ContainerProto_offsets_[1] = { GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(ContainerProto, cont_), }; @@ -267,6 +295,8 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::generated_pool(), ::google::protobuf::MessageFactory::generated_factory(), sizeof(ContainerProto)); + LineJoin_descriptor_ = file->enum_type(0); + LineCap_descriptor_ = file->enum_type(1); } namespace { @@ -281,6 +311,8 @@ void protobuf_RegisterTypes(const ::std::string&) { protobuf_AssignDescriptorsOnce(); ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( DashDotProto_descriptor_, &DashDotProto::default_instance()); + ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( + PathSymProto_descriptor_, &PathSymProto::default_instance()); ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( LineRuleProto_descriptor_, &LineRuleProto::default_instance()); ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage( @@ -310,6 +342,8 @@ void protobuf_RegisterTypes(const ::std::string&) { void protobuf_ShutdownFile_drules_5fstruct_2eproto() { delete DashDotProto::default_instance_; delete DashDotProto_reflection_; + delete PathSymProto::default_instance_; + delete PathSymProto_reflection_; delete LineRuleProto::default_instance_; delete LineRuleProto_reflection_; delete LineDefProto::default_instance_; @@ -342,37 +376,46 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() { ::google::protobuf::DescriptorPool::InternalAddGeneratedFile( "\n\023drules_struct.proto\"*\n\014DashDotProto\022\n\n" - "\002dd\030\001 \003(\001\022\016\n\006offset\030\002 \001(\001\"_\n\rLineRulePro" - "to\022\r\n\005width\030\001 \002(\001\022\r\n\005color\030\002 \002(\r\022\036\n\007dash" - "dot\030\003 \001(\0132\r.DashDotProto\022\020\n\010priority\030\004 \002" - "(\005\"L\n\014LineDefProto\022\r\n\005width\030\001 \002(\001\022\r\n\005col" - "or\030\002 \002(\r\022\036\n\007dashdot\030\003 \001(\0132\r.DashDotProto" - "\"O\n\rAreaRuleProto\022\r\n\005color\030\001 \002(\r\022\035\n\006bord" - "er\030\002 \001(\0132\r.LineDefProto\022\020\n\010priority\030\003 \002(" - "\005\"I\n\017SymbolRuleProto\022\014\n\004name\030\001 \002(\t\022\026\n\016ap" - "ply_for_type\030\002 \001(\005\022\020\n\010priority\030\003 \002(\005\"F\n\017" - "CaptionDefProto\022\016\n\006height\030\001 \002(\005\022\r\n\005color" - "\030\002 \002(\r\022\024\n\014stroke_color\030\003 \001(\r\"l\n\020CaptionR" - "uleProto\022!\n\007primary\030\001 \002(\0132\020.CaptionDefPr" - "oto\022#\n\tsecondary\030\002 \001(\0132\020.CaptionDefProto" - "\022\020\n\010priority\030\003 \002(\005\"a\n\017CircleRuleProto\022\016\n" - "\006radius\030\001 \002(\001\022\r\n\005color\030\002 \002(\r\022\035\n\006border\030\003" - " \001(\0132\r.LineDefProto\022\020\n\010priority\030\004 \002(\005\"m\n" - "\021PathTextRuleProto\022!\n\007primary\030\001 \002(\0132\020.Ca" - "ptionDefProto\022#\n\tsecondary\030\002 \001(\0132\020.Capti" - "onDefProto\022\020\n\010priority\030\003 \002(\005\"\355\001\n\020DrawEle" - "mentProto\022\r\n\005scale\030\001 \002(\005\022\035\n\005lines\030\002 \003(\0132" - "\016.LineRuleProto\022\034\n\004area\030\003 \001(\0132\016.AreaRule" - "Proto\022 \n\006symbol\030\004 \001(\0132\020.SymbolRuleProto\022" - "\"\n\007caption\030\005 \001(\0132\021.CaptionRuleProto\022 \n\006c" - "ircle\030\006 \001(\0132\020.CircleRuleProto\022%\n\tpath_te" - "xt\030\007 \001(\0132\022.PathTextRuleProto\"G\n\023ClassifE" - "lementProto\022\014\n\004name\030\001 \002(\t\022\"\n\007element\030\002 \003" - "(\0132\021.DrawElementProto\"4\n\016ContainerProto\022" - "\"\n\004cont\030\001 \003(\0132\024.ClassifElementProto", 1155); + "\002dd\030\001 \003(\001\022\016\n\006offset\030\002 \001(\001\":\n\014PathSymProt" + "o\022\014\n\004name\030\001 \002(\t\022\014\n\004step\030\002 \002(\001\022\016\n\006offset\030" + "\003 \001(\001\"\257\001\n\rLineRuleProto\022\r\n\005width\030\001 \002(\001\022\r" + "\n\005color\030\002 \002(\r\022\036\n\007dashdot\030\003 \001(\0132\r.DashDot" + "Proto\022\020\n\010priority\030\004 \002(\005\022\036\n\007pathsym\030\005 \001(\013" + "2\r.PathSymProto\022\027\n\004join\030\006 \001(\0162\t.LineJoin" + "\022\025\n\003cap\030\007 \001(\0162\010.LineCap\"\234\001\n\014LineDefProto" + "\022\r\n\005width\030\001 \002(\001\022\r\n\005color\030\002 \002(\r\022\036\n\007dashdo" + "t\030\003 \001(\0132\r.DashDotProto\022\036\n\007pathsym\030\004 \001(\0132" + "\r.PathSymProto\022\027\n\004join\030\006 \001(\0162\t.LineJoin\022" + "\025\n\003cap\030\007 \001(\0162\010.LineCap\"O\n\rAreaRuleProto\022" + "\r\n\005color\030\001 \002(\r\022\035\n\006border\030\002 \001(\0132\r.LineDef" + "Proto\022\020\n\010priority\030\003 \002(\005\"I\n\017SymbolRulePro" + "to\022\014\n\004name\030\001 \002(\t\022\026\n\016apply_for_type\030\002 \001(\005" + "\022\020\n\010priority\030\003 \002(\005\"F\n\017CaptionDefProto\022\016\n" + "\006height\030\001 \002(\005\022\r\n\005color\030\002 \002(\r\022\024\n\014stroke_c" + "olor\030\003 \001(\r\"l\n\020CaptionRuleProto\022!\n\007primar" + "y\030\001 \002(\0132\020.CaptionDefProto\022#\n\tsecondary\030\002" + " \001(\0132\020.CaptionDefProto\022\020\n\010priority\030\003 \002(\005" + "\"a\n\017CircleRuleProto\022\016\n\006radius\030\001 \002(\001\022\r\n\005c" + "olor\030\002 \002(\r\022\035\n\006border\030\003 \001(\0132\r.LineDefProt" + "o\022\020\n\010priority\030\004 \002(\005\"m\n\021PathTextRuleProto" + "\022!\n\007primary\030\001 \002(\0132\020.CaptionDefProto\022#\n\ts" + "econdary\030\002 \001(\0132\020.CaptionDefProto\022\020\n\010prio" + "rity\030\003 \002(\005\"\355\001\n\020DrawElementProto\022\r\n\005scale" + "\030\001 \002(\005\022\035\n\005lines\030\002 \003(\0132\016.LineRuleProto\022\034\n" + "\004area\030\003 \001(\0132\016.AreaRuleProto\022 \n\006symbol\030\004 " + "\001(\0132\020.SymbolRuleProto\022\"\n\007caption\030\005 \001(\0132\021" + ".CaptionRuleProto\022 \n\006circle\030\006 \001(\0132\020.Circ" + "leRuleProto\022%\n\tpath_text\030\007 \001(\0132\022.PathTex" + "tRuleProto\"G\n\023ClassifElementProto\022\014\n\004nam" + "e\030\001 \002(\t\022\"\n\007element\030\002 \003(\0132\021.DrawElementPr" + "oto\"4\n\016ContainerProto\022\"\n\004cont\030\001 \003(\0132\024.Cl" + "assifElementProto*(\n\010LineJoin\022\r\n\tROUNDJO" + "IN\020\000\022\r\n\tBEVELJOIN\020\001*$\n\007LineCap\022\014\n\010ROUNDC" + "AP\020\000\022\013\n\007BUTTCAP\020\001", 1457); ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile( "drules_struct.proto", &protobuf_RegisterTypes); DashDotProto::default_instance_ = new DashDotProto(); + PathSymProto::default_instance_ = new PathSymProto(); LineRuleProto::default_instance_ = new LineRuleProto(); LineDefProto::default_instance_ = new LineDefProto(); AreaRuleProto::default_instance_ = new AreaRuleProto(); @@ -385,6 +428,7 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() { ClassifElementProto::default_instance_ = new ClassifElementProto(); ContainerProto::default_instance_ = new ContainerProto(); DashDotProto::default_instance_->InitAsDefaultInstance(); + PathSymProto::default_instance_->InitAsDefaultInstance(); LineRuleProto::default_instance_->InitAsDefaultInstance(); LineDefProto::default_instance_->InitAsDefaultInstance(); AreaRuleProto::default_instance_->InitAsDefaultInstance(); @@ -406,6 +450,34 @@ struct StaticDescriptorInitializer_drules_5fstruct_2eproto { } } static_descriptor_initializer_drules_5fstruct_2eproto_; +const ::google::protobuf::EnumDescriptor* LineJoin_descriptor() { + protobuf_AssignDescriptorsOnce(); + return LineJoin_descriptor_; +} +bool LineJoin_IsValid(int value) { + switch(value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +const ::google::protobuf::EnumDescriptor* LineCap_descriptor() { + protobuf_AssignDescriptorsOnce(); + return LineCap_descriptor_; +} +bool LineCap_IsValid(int value) { + switch(value) { + case 0: + case 1: + return true; + default: + return false; + } +} + // =================================================================== @@ -658,6 +730,307 @@ void DashDotProto::Swap(DashDotProto* other) { } +// =================================================================== + +#ifndef _MSC_VER +const int PathSymProto::kNameFieldNumber; +const int PathSymProto::kStepFieldNumber; +const int PathSymProto::kOffsetFieldNumber; +#endif // !_MSC_VER + +PathSymProto::PathSymProto() + : ::google::protobuf::Message() { + SharedCtor(); +} + +void PathSymProto::InitAsDefaultInstance() { +} + +PathSymProto::PathSymProto(const PathSymProto& from) + : ::google::protobuf::Message() { + SharedCtor(); + MergeFrom(from); +} + +void PathSymProto::SharedCtor() { + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + step_ = 0; + offset_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +PathSymProto::~PathSymProto() { + SharedDtor(); +} + +void PathSymProto::SharedDtor() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + } +} + +void PathSymProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const ::google::protobuf::Descriptor* PathSymProto::descriptor() { + protobuf_AssignDescriptorsOnce(); + return PathSymProto_descriptor_; +} + +const PathSymProto& PathSymProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +PathSymProto* PathSymProto::default_instance_ = NULL; + +PathSymProto* PathSymProto::New() const { + return new PathSymProto; +} + +void PathSymProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + step_ = 0; + offset_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); + mutable_unknown_fields()->Clear(); +} + +bool PathSymProto::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())); + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::PARSE); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(17)) goto parse_step; + break; + } + + // required double step = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_step: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &step_))); + set_has_step(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_offset; + break; + } + + // optional double offset = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &offset_))); + set_has_offset(); + } 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::WireFormat::SkipField( + input, tag, mutable_unknown_fields())); + break; + } + } + } + return true; +#undef DO_ +} + +void PathSymProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->name(), output); + } + + // required double step = 2; + if (has_step()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->step(), output); + } + + // optional double offset = 3; + if (has_offset()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->offset(), output); + } + + if (!unknown_fields().empty()) { + ::google::protobuf::internal::WireFormat::SerializeUnknownFields( + unknown_fields(), output); + } +} + +::google::protobuf::uint8* PathSymProto::SerializeWithCachedSizesToArray( + ::google::protobuf::uint8* target) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormat::VerifyUTF8String( + this->name().data(), this->name().length(), + ::google::protobuf::internal::WireFormat::SERIALIZE); + target = + ::google::protobuf::internal::WireFormatLite::WriteStringToArray( + 1, this->name(), target); + } + + // required double step = 2; + if (has_step()) { + target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(2, this->step(), target); + } + + // optional double offset = 3; + if (has_offset()) { + target = ::google::protobuf::internal::WireFormatLite::WriteDoubleToArray(3, this->offset(), target); + } + + if (!unknown_fields().empty()) { + target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( + unknown_fields(), target); + } + return target; +} + +int PathSymProto::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()); + } + + // required double step = 2; + if (has_step()) { + total_size += 1 + 8; + } + + // optional double offset = 3; + if (has_offset()) { + total_size += 1 + 8; + } + + } + if (!unknown_fields().empty()) { + total_size += + ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize( + unknown_fields()); + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PathSymProto::MergeFrom(const ::google::protobuf::Message& from) { + GOOGLE_CHECK_NE(&from, this); + const PathSymProto* source = + ::google::protobuf::internal::dynamic_cast_if_available( + &from); + if (source == NULL) { + ::google::protobuf::internal::ReflectionOps::Merge(from, this); + } else { + MergeFrom(*source); + } +} + +void PathSymProto::MergeFrom(const PathSymProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_step()) { + set_step(from.step()); + } + if (from.has_offset()) { + set_offset(from.offset()); + } + } + mutable_unknown_fields()->MergeFrom(from.unknown_fields()); +} + +void PathSymProto::CopyFrom(const ::google::protobuf::Message& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +void PathSymProto::CopyFrom(const PathSymProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PathSymProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void PathSymProto::Swap(PathSymProto* other) { + if (other != this) { + std::swap(name_, other->name_); + std::swap(step_, other->step_); + std::swap(offset_, other->offset_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + _unknown_fields_.Swap(&other->_unknown_fields_); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::google::protobuf::Metadata PathSymProto::GetMetadata() const { + protobuf_AssignDescriptorsOnce(); + ::google::protobuf::Metadata metadata; + metadata.descriptor = PathSymProto_descriptor_; + metadata.reflection = PathSymProto_reflection_; + return metadata; +} + + // =================================================================== #ifndef _MSC_VER @@ -665,6 +1038,9 @@ const int LineRuleProto::kWidthFieldNumber; const int LineRuleProto::kColorFieldNumber; const int LineRuleProto::kDashdotFieldNumber; const int LineRuleProto::kPriorityFieldNumber; +const int LineRuleProto::kPathsymFieldNumber; +const int LineRuleProto::kJoinFieldNumber; +const int LineRuleProto::kCapFieldNumber; #endif // !_MSC_VER LineRuleProto::LineRuleProto() @@ -674,6 +1050,7 @@ LineRuleProto::LineRuleProto() void LineRuleProto::InitAsDefaultInstance() { dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance()); + pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance()); } LineRuleProto::LineRuleProto(const LineRuleProto& from) @@ -688,6 +1065,9 @@ void LineRuleProto::SharedCtor() { color_ = 0u; dashdot_ = NULL; priority_ = 0; + pathsym_ = NULL; + join_ = 0; + cap_ = 0; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } @@ -698,6 +1078,7 @@ LineRuleProto::~LineRuleProto() { void LineRuleProto::SharedDtor() { if (this != default_instance_) { delete dashdot_; + delete pathsym_; } } @@ -729,6 +1110,11 @@ void LineRuleProto::Clear() { if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear(); } priority_ = 0; + if (has_pathsym()) { + if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear(); + } + join_ = 0; + cap_ = 0; } ::memset(_has_bits_, 0, sizeof(_has_bits_)); mutable_unknown_fields()->Clear(); @@ -797,6 +1183,62 @@ bool LineRuleProto::MergePartialFromCodedStream( } else { goto handle_uninterpreted; } + if (input->ExpectTag(42)) goto parse_pathsym; + break; + } + + // optional .PathSymProto pathsym = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_pathsym: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_pathsym())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_join; + break; + } + + // optional .LineJoin join = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_join: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (LineJoin_IsValid(value)) { + set_join(static_cast< LineJoin >(value)); + } else { + mutable_unknown_fields()->AddVarint(6, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(56)) goto parse_cap; + break; + } + + // optional .LineCap cap = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_cap: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (LineCap_IsValid(value)) { + set_cap(static_cast< LineCap >(value)); + } else { + mutable_unknown_fields()->AddVarint(7, value); + } + } else { + goto handle_uninterpreted; + } if (input->ExpectAtEnd()) return true; break; } @@ -840,6 +1282,24 @@ void LineRuleProto::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output); } + // optional .PathSymProto pathsym = 5; + if (has_pathsym()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 5, this->pathsym(), output); + } + + // optional .LineJoin join = 6; + if (has_join()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->join(), output); + } + + // optional .LineCap cap = 7; + if (has_cap()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 7, this->cap(), output); + } + if (!unknown_fields().empty()) { ::google::protobuf::internal::WireFormat::SerializeUnknownFields( unknown_fields(), output); @@ -870,6 +1330,25 @@ void LineRuleProto::SerializeWithCachedSizes( target = ::google::protobuf::internal::WireFormatLite::WriteInt32ToArray(4, this->priority(), target); } + // optional .PathSymProto pathsym = 5; + if (has_pathsym()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 5, this->pathsym(), target); + } + + // optional .LineJoin join = 6; + if (has_join()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 6, this->join(), target); + } + + // optional .LineCap cap = 7; + if (has_cap()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 7, this->cap(), target); + } + if (!unknown_fields().empty()) { target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( unknown_fields(), target); @@ -907,6 +1386,25 @@ int LineRuleProto::ByteSize() const { this->priority()); } + // optional .PathSymProto pathsym = 5; + if (has_pathsym()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->pathsym()); + } + + // optional .LineJoin join = 6; + if (has_join()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->join()); + } + + // optional .LineCap cap = 7; + if (has_cap()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap()); + } + } if (!unknown_fields().empty()) { total_size += @@ -946,6 +1444,15 @@ void LineRuleProto::MergeFrom(const LineRuleProto& from) { if (from.has_priority()) { set_priority(from.priority()); } + if (from.has_pathsym()) { + mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym()); + } + if (from.has_join()) { + set_join(from.join()); + } + if (from.has_cap()) { + set_cap(from.cap()); + } } mutable_unknown_fields()->MergeFrom(from.unknown_fields()); } @@ -965,6 +1472,9 @@ void LineRuleProto::CopyFrom(const LineRuleProto& from) { bool LineRuleProto::IsInitialized() const { if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false; + if (has_pathsym()) { + if (!this->pathsym().IsInitialized()) return false; + } return true; } @@ -974,6 +1484,9 @@ void LineRuleProto::Swap(LineRuleProto* other) { std::swap(color_, other->color_); std::swap(dashdot_, other->dashdot_); std::swap(priority_, other->priority_); + std::swap(pathsym_, other->pathsym_); + std::swap(join_, other->join_); + std::swap(cap_, other->cap_); std::swap(_has_bits_[0], other->_has_bits_[0]); _unknown_fields_.Swap(&other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); @@ -995,6 +1508,9 @@ void LineRuleProto::Swap(LineRuleProto* other) { const int LineDefProto::kWidthFieldNumber; const int LineDefProto::kColorFieldNumber; const int LineDefProto::kDashdotFieldNumber; +const int LineDefProto::kPathsymFieldNumber; +const int LineDefProto::kJoinFieldNumber; +const int LineDefProto::kCapFieldNumber; #endif // !_MSC_VER LineDefProto::LineDefProto() @@ -1004,6 +1520,7 @@ LineDefProto::LineDefProto() void LineDefProto::InitAsDefaultInstance() { dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance()); + pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance()); } LineDefProto::LineDefProto(const LineDefProto& from) @@ -1017,6 +1534,9 @@ void LineDefProto::SharedCtor() { width_ = 0; color_ = 0u; dashdot_ = NULL; + pathsym_ = NULL; + join_ = 0; + cap_ = 0; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } @@ -1027,6 +1547,7 @@ LineDefProto::~LineDefProto() { void LineDefProto::SharedDtor() { if (this != default_instance_) { delete dashdot_; + delete pathsym_; } } @@ -1057,6 +1578,11 @@ void LineDefProto::Clear() { if (has_dashdot()) { if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear(); } + if (has_pathsym()) { + if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear(); + } + join_ = 0; + cap_ = 0; } ::memset(_has_bits_, 0, sizeof(_has_bits_)); mutable_unknown_fields()->Clear(); @@ -1109,6 +1635,62 @@ bool LineDefProto::MergePartialFromCodedStream( } else { goto handle_uninterpreted; } + if (input->ExpectTag(34)) goto parse_pathsym; + break; + } + + // optional .PathSymProto pathsym = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_pathsym: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_pathsym())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_join; + break; + } + + // optional .LineJoin join = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_join: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (LineJoin_IsValid(value)) { + set_join(static_cast< LineJoin >(value)); + } else { + mutable_unknown_fields()->AddVarint(6, value); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(56)) goto parse_cap; + break; + } + + // optional .LineCap cap = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_cap: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (LineCap_IsValid(value)) { + set_cap(static_cast< LineCap >(value)); + } else { + mutable_unknown_fields()->AddVarint(7, value); + } + } else { + goto handle_uninterpreted; + } if (input->ExpectAtEnd()) return true; break; } @@ -1147,6 +1729,24 @@ void LineDefProto::SerializeWithCachedSizes( 3, this->dashdot(), output); } + // optional .PathSymProto pathsym = 4; + if (has_pathsym()) { + ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray( + 4, this->pathsym(), output); + } + + // optional .LineJoin join = 6; + if (has_join()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->join(), output); + } + + // optional .LineCap cap = 7; + if (has_cap()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 7, this->cap(), output); + } + if (!unknown_fields().empty()) { ::google::protobuf::internal::WireFormat::SerializeUnknownFields( unknown_fields(), output); @@ -1172,6 +1772,25 @@ void LineDefProto::SerializeWithCachedSizes( 3, this->dashdot(), target); } + // optional .PathSymProto pathsym = 4; + if (has_pathsym()) { + target = ::google::protobuf::internal::WireFormatLite:: + WriteMessageNoVirtualToArray( + 4, this->pathsym(), target); + } + + // optional .LineJoin join = 6; + if (has_join()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 6, this->join(), target); + } + + // optional .LineCap cap = 7; + if (has_cap()) { + target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray( + 7, this->cap(), target); + } + if (!unknown_fields().empty()) { target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray( unknown_fields(), target); @@ -1202,6 +1821,25 @@ int LineDefProto::ByteSize() const { this->dashdot()); } + // optional .PathSymProto pathsym = 4; + if (has_pathsym()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->pathsym()); + } + + // optional .LineJoin join = 6; + if (has_join()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->join()); + } + + // optional .LineCap cap = 7; + if (has_cap()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap()); + } + } if (!unknown_fields().empty()) { total_size += @@ -1238,6 +1876,15 @@ void LineDefProto::MergeFrom(const LineDefProto& from) { if (from.has_dashdot()) { mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot()); } + if (from.has_pathsym()) { + mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym()); + } + if (from.has_join()) { + set_join(from.join()); + } + if (from.has_cap()) { + set_cap(from.cap()); + } } mutable_unknown_fields()->MergeFrom(from.unknown_fields()); } @@ -1257,6 +1904,9 @@ void LineDefProto::CopyFrom(const LineDefProto& from) { bool LineDefProto::IsInitialized() const { if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + if (has_pathsym()) { + if (!this->pathsym().IsInitialized()) return false; + } return true; } @@ -1265,6 +1915,9 @@ void LineDefProto::Swap(LineDefProto* other) { std::swap(width_, other->width_); std::swap(color_, other->color_); std::swap(dashdot_, other->dashdot_); + std::swap(pathsym_, other->pathsym_); + std::swap(join_, other->join_); + std::swap(cap_, other->cap_); std::swap(_has_bits_[0], other->_has_bits_[0]); _unknown_fields_.Swap(&other->_unknown_fields_); std::swap(_cached_size_, other->_cached_size_); diff --git a/indexer/drules_struct.pb.h b/indexer/drules_struct.pb.h index 9d3b27ba46..4fed524db7 100644 --- a/indexer/drules_struct.pb.h +++ b/indexer/drules_struct.pb.h @@ -31,6 +31,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto(); void protobuf_ShutdownFile_drules_5fstruct_2eproto(); class DashDotProto; +class PathSymProto; class LineRuleProto; class LineDefProto; class AreaRuleProto; @@ -43,6 +44,44 @@ class DrawElementProto; class ClassifElementProto; class ContainerProto; +enum LineJoin { + ROUNDJOIN = 0, + BEVELJOIN = 1 +}; +bool LineJoin_IsValid(int value); +const LineJoin LineJoin_MIN = ROUNDJOIN; +const LineJoin LineJoin_MAX = BEVELJOIN; +const int LineJoin_ARRAYSIZE = LineJoin_MAX + 1; + +const ::google::protobuf::EnumDescriptor* LineJoin_descriptor(); +inline const ::std::string& LineJoin_Name(LineJoin value) { + return ::google::protobuf::internal::NameOfEnum( + LineJoin_descriptor(), value); +} +inline bool LineJoin_Parse( + const ::std::string& name, LineJoin* value) { + return ::google::protobuf::internal::ParseNamedEnum( + LineJoin_descriptor(), name, value); +} +enum LineCap { + ROUNDCAP = 0, + BUTTCAP = 1 +}; +bool LineCap_IsValid(int value); +const LineCap LineCap_MIN = ROUNDCAP; +const LineCap LineCap_MAX = BUTTCAP; +const int LineCap_ARRAYSIZE = LineCap_MAX + 1; + +const ::google::protobuf::EnumDescriptor* LineCap_descriptor(); +inline const ::std::string& LineCap_Name(LineCap value) { + return ::google::protobuf::internal::NameOfEnum( + LineCap_descriptor(), value); +} +inline bool LineCap_Parse( + const ::std::string& name, LineCap* value) { + return ::google::protobuf::internal::ParseNamedEnum( + LineCap_descriptor(), name, value); +} // =================================================================== class DashDotProto : public ::google::protobuf::Message { @@ -140,6 +179,112 @@ class DashDotProto : public ::google::protobuf::Message { }; // ------------------------------------------------------------------- +class PathSymProto : public ::google::protobuf::Message { + public: + PathSymProto(); + virtual ~PathSymProto(); + + PathSymProto(const PathSymProto& from); + + inline PathSymProto& operator=(const PathSymProto& from) { + CopyFrom(from); + return *this; + } + + inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const { + return _unknown_fields_; + } + + inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() { + return &_unknown_fields_; + } + + static const ::google::protobuf::Descriptor* descriptor(); + static const PathSymProto& default_instance(); + + void Swap(PathSymProto* other); + + // implements Message ---------------------------------------------- + + PathSymProto* New() const; + void CopyFrom(const ::google::protobuf::Message& from); + void MergeFrom(const ::google::protobuf::Message& from); + void CopyFrom(const PathSymProto& from); + void MergeFrom(const PathSymProto& from); + void Clear(); + bool IsInitialized() const; + + int ByteSize() const; + bool MergePartialFromCodedStream( + ::google::protobuf::io::CodedInputStream* input); + void SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const; + ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const; + int GetCachedSize() const { return _cached_size_; } + private: + void SharedCtor(); + void SharedDtor(); + void SetCachedSize(int size) const; + public: + + ::google::protobuf::Metadata GetMetadata() const; + + // nested types ---------------------------------------------------- + + // accessors ------------------------------------------------------- + + // 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(); + + // required double step = 2; + inline bool has_step() const; + inline void clear_step(); + static const int kStepFieldNumber = 2; + inline double step() const; + inline void set_step(double value); + + // optional double offset = 3; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 3; + inline double offset() const; + inline void set_offset(double value); + + // @@protoc_insertion_point(class_scope:PathSymProto) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_step(); + inline void clear_has_step(); + inline void set_has_offset(); + inline void clear_has_offset(); + + ::google::protobuf::UnknownFieldSet _unknown_fields_; + + ::std::string* name_; + double step_; + double offset_; + + 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 PathSymProto* default_instance_; +}; +// ------------------------------------------------------------------- + class LineRuleProto : public ::google::protobuf::Message { public: LineRuleProto(); @@ -223,6 +368,28 @@ class LineRuleProto : public ::google::protobuf::Message { inline ::google::protobuf::int32 priority() const; inline void set_priority(::google::protobuf::int32 value); + // optional .PathSymProto pathsym = 5; + inline bool has_pathsym() const; + inline void clear_pathsym(); + static const int kPathsymFieldNumber = 5; + inline const ::PathSymProto& pathsym() const; + inline ::PathSymProto* mutable_pathsym(); + inline ::PathSymProto* release_pathsym(); + + // optional .LineJoin join = 6; + inline bool has_join() const; + inline void clear_join(); + static const int kJoinFieldNumber = 6; + inline LineJoin join() const; + inline void set_join(LineJoin value); + + // optional .LineCap cap = 7; + inline bool has_cap() const; + inline void clear_cap(); + static const int kCapFieldNumber = 7; + inline LineCap cap() const; + inline void set_cap(LineCap value); + // @@protoc_insertion_point(class_scope:LineRuleProto) private: inline void set_has_width(); @@ -233,6 +400,12 @@ class LineRuleProto : public ::google::protobuf::Message { inline void clear_has_dashdot(); inline void set_has_priority(); inline void clear_has_priority(); + inline void set_has_pathsym(); + inline void clear_has_pathsym(); + inline void set_has_join(); + inline void clear_has_join(); + inline void set_has_cap(); + inline void clear_has_cap(); ::google::protobuf::UnknownFieldSet _unknown_fields_; @@ -240,9 +413,12 @@ class LineRuleProto : public ::google::protobuf::Message { ::DashDotProto* dashdot_; ::google::protobuf::uint32 color_; ::google::protobuf::int32 priority_; + ::PathSymProto* pathsym_; + int join_; + int cap_; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32]; + ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32]; friend void protobuf_AddDesc_drules_5fstruct_2eproto(); friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); @@ -329,6 +505,28 @@ class LineDefProto : public ::google::protobuf::Message { inline ::DashDotProto* mutable_dashdot(); inline ::DashDotProto* release_dashdot(); + // optional .PathSymProto pathsym = 4; + inline bool has_pathsym() const; + inline void clear_pathsym(); + static const int kPathsymFieldNumber = 4; + inline const ::PathSymProto& pathsym() const; + inline ::PathSymProto* mutable_pathsym(); + inline ::PathSymProto* release_pathsym(); + + // optional .LineJoin join = 6; + inline bool has_join() const; + inline void clear_join(); + static const int kJoinFieldNumber = 6; + inline LineJoin join() const; + inline void set_join(LineJoin value); + + // optional .LineCap cap = 7; + inline bool has_cap() const; + inline void clear_cap(); + static const int kCapFieldNumber = 7; + inline LineCap cap() const; + inline void set_cap(LineCap value); + // @@protoc_insertion_point(class_scope:LineDefProto) private: inline void set_has_width(); @@ -337,15 +535,24 @@ class LineDefProto : public ::google::protobuf::Message { inline void clear_has_color(); inline void set_has_dashdot(); inline void clear_has_dashdot(); + inline void set_has_pathsym(); + inline void clear_has_pathsym(); + inline void set_has_join(); + inline void clear_has_join(); + inline void set_has_cap(); + inline void clear_has_cap(); ::google::protobuf::UnknownFieldSet _unknown_fields_; double width_; ::DashDotProto* dashdot_; ::google::protobuf::uint32 color_; + int join_; + ::PathSymProto* pathsym_; + int cap_; mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32]; + ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32]; friend void protobuf_AddDesc_drules_5fstruct_2eproto(); friend void protobuf_AssignDesc_drules_5fstruct_2eproto(); @@ -1376,6 +1583,112 @@ inline void DashDotProto::set_offset(double value) { // ------------------------------------------------------------------- +// PathSymProto + +// required string name = 1; +inline bool PathSymProto::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PathSymProto::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void PathSymProto::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PathSymProto::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& PathSymProto::name() const { + return *name_; +} +inline void PathSymProto::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void PathSymProto::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void PathSymProto::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* PathSymProto::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* PathSymProto::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; + } +} + +// required double step = 2; +inline bool PathSymProto::has_step() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PathSymProto::set_has_step() { + _has_bits_[0] |= 0x00000002u; +} +inline void PathSymProto::clear_has_step() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PathSymProto::clear_step() { + step_ = 0; + clear_has_step(); +} +inline double PathSymProto::step() const { + return step_; +} +inline void PathSymProto::set_step(double value) { + set_has_step(); + step_ = value; +} + +// optional double offset = 3; +inline bool PathSymProto::has_offset() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void PathSymProto::set_has_offset() { + _has_bits_[0] |= 0x00000004u; +} +inline void PathSymProto::clear_has_offset() { + _has_bits_[0] &= ~0x00000004u; +} +inline void PathSymProto::clear_offset() { + offset_ = 0; + clear_has_offset(); +} +inline double PathSymProto::offset() const { + return offset_; +} +inline void PathSymProto::set_offset(double value) { + set_has_offset(); + offset_ = value; +} + +// ------------------------------------------------------------------- + // LineRuleProto // required double width = 1; @@ -1473,6 +1786,81 @@ inline void LineRuleProto::set_priority(::google::protobuf::int32 value) { priority_ = value; } +// optional .PathSymProto pathsym = 5; +inline bool LineRuleProto::has_pathsym() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void LineRuleProto::set_has_pathsym() { + _has_bits_[0] |= 0x00000010u; +} +inline void LineRuleProto::clear_has_pathsym() { + _has_bits_[0] &= ~0x00000010u; +} +inline void LineRuleProto::clear_pathsym() { + if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear(); + clear_has_pathsym(); +} +inline const ::PathSymProto& LineRuleProto::pathsym() const { + return pathsym_ != NULL ? *pathsym_ : *default_instance_->pathsym_; +} +inline ::PathSymProto* LineRuleProto::mutable_pathsym() { + set_has_pathsym(); + if (pathsym_ == NULL) pathsym_ = new ::PathSymProto; + return pathsym_; +} +inline ::PathSymProto* LineRuleProto::release_pathsym() { + clear_has_pathsym(); + ::PathSymProto* temp = pathsym_; + pathsym_ = NULL; + return temp; +} + +// optional .LineJoin join = 6; +inline bool LineRuleProto::has_join() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void LineRuleProto::set_has_join() { + _has_bits_[0] |= 0x00000020u; +} +inline void LineRuleProto::clear_has_join() { + _has_bits_[0] &= ~0x00000020u; +} +inline void LineRuleProto::clear_join() { + join_ = 0; + clear_has_join(); +} +inline LineJoin LineRuleProto::join() const { + return static_cast< LineJoin >(join_); +} +inline void LineRuleProto::set_join(LineJoin value) { + GOOGLE_DCHECK(LineJoin_IsValid(value)); + set_has_join(); + join_ = value; +} + +// optional .LineCap cap = 7; +inline bool LineRuleProto::has_cap() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void LineRuleProto::set_has_cap() { + _has_bits_[0] |= 0x00000040u; +} +inline void LineRuleProto::clear_has_cap() { + _has_bits_[0] &= ~0x00000040u; +} +inline void LineRuleProto::clear_cap() { + cap_ = 0; + clear_has_cap(); +} +inline LineCap LineRuleProto::cap() const { + return static_cast< LineCap >(cap_); +} +inline void LineRuleProto::set_cap(LineCap value) { + GOOGLE_DCHECK(LineCap_IsValid(value)); + set_has_cap(); + cap_ = value; +} + // ------------------------------------------------------------------- // LineDefProto @@ -1550,6 +1938,81 @@ inline ::DashDotProto* LineDefProto::release_dashdot() { return temp; } +// optional .PathSymProto pathsym = 4; +inline bool LineDefProto::has_pathsym() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void LineDefProto::set_has_pathsym() { + _has_bits_[0] |= 0x00000008u; +} +inline void LineDefProto::clear_has_pathsym() { + _has_bits_[0] &= ~0x00000008u; +} +inline void LineDefProto::clear_pathsym() { + if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear(); + clear_has_pathsym(); +} +inline const ::PathSymProto& LineDefProto::pathsym() const { + return pathsym_ != NULL ? *pathsym_ : *default_instance_->pathsym_; +} +inline ::PathSymProto* LineDefProto::mutable_pathsym() { + set_has_pathsym(); + if (pathsym_ == NULL) pathsym_ = new ::PathSymProto; + return pathsym_; +} +inline ::PathSymProto* LineDefProto::release_pathsym() { + clear_has_pathsym(); + ::PathSymProto* temp = pathsym_; + pathsym_ = NULL; + return temp; +} + +// optional .LineJoin join = 6; +inline bool LineDefProto::has_join() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void LineDefProto::set_has_join() { + _has_bits_[0] |= 0x00000010u; +} +inline void LineDefProto::clear_has_join() { + _has_bits_[0] &= ~0x00000010u; +} +inline void LineDefProto::clear_join() { + join_ = 0; + clear_has_join(); +} +inline LineJoin LineDefProto::join() const { + return static_cast< LineJoin >(join_); +} +inline void LineDefProto::set_join(LineJoin value) { + GOOGLE_DCHECK(LineJoin_IsValid(value)); + set_has_join(); + join_ = value; +} + +// optional .LineCap cap = 7; +inline bool LineDefProto::has_cap() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void LineDefProto::set_has_cap() { + _has_bits_[0] |= 0x00000020u; +} +inline void LineDefProto::clear_has_cap() { + _has_bits_[0] &= ~0x00000020u; +} +inline void LineDefProto::clear_cap() { + cap_ = 0; + clear_has_cap(); +} +inline LineCap LineDefProto::cap() const { + return static_cast< LineCap >(cap_); +} +inline void LineDefProto::set_cap(LineCap value) { + GOOGLE_DCHECK(LineCap_IsValid(value)); + set_has_cap(); + cap_ = value; +} + // ------------------------------------------------------------------- // AreaRuleProto @@ -2389,6 +2852,14 @@ ContainerProto::mutable_cont() { namespace google { namespace protobuf { +template <> +inline const EnumDescriptor* GetEnumDescriptor< LineJoin>() { + return LineJoin_descriptor(); +} +template <> +inline const EnumDescriptor* GetEnumDescriptor< LineCap>() { + return LineCap_descriptor(); +} } // namespace google } // namespace protobuf diff --git a/indexer/drules_struct.proto b/indexer/drules_struct.proto index 9edb326051..25a32fc767 100644 --- a/indexer/drules_struct.proto +++ b/indexer/drules_struct.proto @@ -6,12 +6,34 @@ message DashDotProto optional double offset = 2; } +message PathSymProto +{ + required string name = 1; + required double step = 2; + optional double offset = 3; +} + +enum LineJoin +{ + ROUNDJOIN = 0; + BEVELJOIN = 1; +} + +enum LineCap +{ + ROUNDCAP = 0; + BUTTCAP = 1; +} + message LineRuleProto { required double width = 1; required uint32 color = 2; optional DashDotProto dashdot = 3; required int32 priority = 4; + optional PathSymProto pathsym = 5; + optional LineJoin join = 6; + optional LineCap cap = 7; } message LineDefProto @@ -19,6 +41,9 @@ message LineDefProto required double width = 1; required uint32 color = 2; optional DashDotProto dashdot = 3; + optional PathSymProto pathsym = 4; + optional LineJoin join = 6; + optional LineCap cap = 7; } message AreaRuleProto diff --git a/indexer/drules_struct_lite.pb.cc b/indexer/drules_struct_lite.pb.cc index a8d8d91a31..aa31b5fcc4 100644 --- a/indexer/drules_struct_lite.pb.cc +++ b/indexer/drules_struct_lite.pb.cc @@ -12,6 +12,7 @@ void protobuf_ShutdownFile_drules_5fstruct_2eproto() { delete DashDotProto::default_instance_; + delete PathSymProto::default_instance_; delete LineRuleProto::default_instance_; delete LineDefProto::default_instance_; delete AreaRuleProto::default_instance_; @@ -32,6 +33,7 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() { GOOGLE_PROTOBUF_VERIFY_VERSION; DashDotProto::default_instance_ = new DashDotProto(); + PathSymProto::default_instance_ = new PathSymProto(); LineRuleProto::default_instance_ = new LineRuleProto(); LineDefProto::default_instance_ = new LineDefProto(); AreaRuleProto::default_instance_ = new AreaRuleProto(); @@ -44,6 +46,7 @@ void protobuf_AddDesc_drules_5fstruct_2eproto() { ClassifElementProto::default_instance_ = new ClassifElementProto(); ContainerProto::default_instance_ = new ContainerProto(); DashDotProto::default_instance_->InitAsDefaultInstance(); + PathSymProto::default_instance_->InitAsDefaultInstance(); LineRuleProto::default_instance_->InitAsDefaultInstance(); LineDefProto::default_instance_->InitAsDefaultInstance(); AreaRuleProto::default_instance_->InitAsDefaultInstance(); @@ -65,6 +68,26 @@ struct StaticDescriptorInitializer_drules_5fstruct_2eproto { } } static_descriptor_initializer_drules_5fstruct_2eproto_; +bool LineJoin_IsValid(int value) { + switch(value) { + case 0: + case 1: + return true; + default: + return false; + } +} + +bool LineCap_IsValid(int value) { + switch(value) { + case 0: + case 1: + return true; + default: + return false; + } +} + // =================================================================== @@ -152,7 +175,7 @@ bool DashDotProto::MergePartialFromCodedStream( if (input->ExpectTag(17)) goto parse_offset; break; } - + // optional double offset = 2; case 2: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -168,7 +191,7 @@ bool DashDotProto::MergePartialFromCodedStream( if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -191,23 +214,23 @@ void DashDotProto::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteDouble( 1, this->dd(i), output); } - + // optional double offset = 2; if (has_offset()) { ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->offset(), output); } - + } int DashDotProto::ByteSize() const { int total_size = 0; - + if (_has_bits_[1 / 32] & (0xffu << (1 % 32))) { // optional double offset = 2; if (has_offset()) { total_size += 1 + 8; } - + } // repeated double dd = 1; { @@ -215,7 +238,7 @@ int DashDotProto::ByteSize() const { 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(); @@ -244,7 +267,7 @@ void DashDotProto::CopyFrom(const DashDotProto& from) { } bool DashDotProto::IsInitialized() const { - + return true; } @@ -262,6 +285,237 @@ void DashDotProto::Swap(DashDotProto* other) { } +// =================================================================== + +#ifndef _MSC_VER +const int PathSymProto::kNameFieldNumber; +const int PathSymProto::kStepFieldNumber; +const int PathSymProto::kOffsetFieldNumber; +#endif // !_MSC_VER + +PathSymProto::PathSymProto() + : ::google::protobuf::MessageLite() { + SharedCtor(); +} + +void PathSymProto::InitAsDefaultInstance() { +} + +PathSymProto::PathSymProto(const PathSymProto& from) + : ::google::protobuf::MessageLite() { + SharedCtor(); + MergeFrom(from); +} + +void PathSymProto::SharedCtor() { + _cached_size_ = 0; + name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString); + step_ = 0; + offset_ = 0; + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +PathSymProto::~PathSymProto() { + SharedDtor(); +} + +void PathSymProto::SharedDtor() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + delete name_; + } + if (this != default_instance_) { + } +} + +void PathSymProto::SetCachedSize(int size) const { + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); +} +const PathSymProto& PathSymProto::default_instance() { + if (default_instance_ == NULL) protobuf_AddDesc_drules_5fstruct_2eproto(); return *default_instance_; +} + +PathSymProto* PathSymProto::default_instance_ = NULL; + +PathSymProto* PathSymProto::New() const { + return new PathSymProto; +} + +void PathSymProto::Clear() { + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (has_name()) { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + } + step_ = 0; + offset_ = 0; + } + ::memset(_has_bits_, 0, sizeof(_has_bits_)); +} + +bool PathSymProto::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(17)) goto parse_step; + break; + } + + // required double step = 2; + case 2: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_step: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &step_))); + set_has_step(); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(25)) goto parse_offset; + break; + } + + // optional double offset = 3; + case 3: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_FIXED64) { + parse_offset: + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + double, ::google::protobuf::internal::WireFormatLite::TYPE_DOUBLE>( + input, &offset_))); + set_has_offset(); + } 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 PathSymProto::SerializeWithCachedSizes( + ::google::protobuf::io::CodedOutputStream* output) const { + // required string name = 1; + if (has_name()) { + ::google::protobuf::internal::WireFormatLite::WriteString( + 1, this->name(), output); + } + + // required double step = 2; + if (has_step()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(2, this->step(), output); + } + + // optional double offset = 3; + if (has_offset()) { + ::google::protobuf::internal::WireFormatLite::WriteDouble(3, this->offset(), output); + } + +} + +int PathSymProto::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()); + } + + // required double step = 2; + if (has_step()) { + total_size += 1 + 8; + } + + // optional double offset = 3; + if (has_offset()) { + total_size += 1 + 8; + } + + } + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); + _cached_size_ = total_size; + GOOGLE_SAFE_CONCURRENT_WRITES_END(); + return total_size; +} + +void PathSymProto::CheckTypeAndMergeFrom( + const ::google::protobuf::MessageLite& from) { + MergeFrom(*::google::protobuf::down_cast(&from)); +} + +void PathSymProto::MergeFrom(const PathSymProto& from) { + GOOGLE_CHECK_NE(&from, this); + if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) { + if (from.has_name()) { + set_name(from.name()); + } + if (from.has_step()) { + set_step(from.step()); + } + if (from.has_offset()) { + set_offset(from.offset()); + } + } +} + +void PathSymProto::CopyFrom(const PathSymProto& from) { + if (&from == this) return; + Clear(); + MergeFrom(from); +} + +bool PathSymProto::IsInitialized() const { + if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; + + return true; +} + +void PathSymProto::Swap(PathSymProto* other) { + if (other != this) { + std::swap(name_, other->name_); + std::swap(step_, other->step_); + std::swap(offset_, other->offset_); + std::swap(_has_bits_[0], other->_has_bits_[0]); + std::swap(_cached_size_, other->_cached_size_); + } +} + +::std::string PathSymProto::GetTypeName() const { + return "PathSymProto"; +} + + // =================================================================== #ifndef _MSC_VER @@ -269,6 +523,9 @@ const int LineRuleProto::kWidthFieldNumber; const int LineRuleProto::kColorFieldNumber; const int LineRuleProto::kDashdotFieldNumber; const int LineRuleProto::kPriorityFieldNumber; +const int LineRuleProto::kPathsymFieldNumber; +const int LineRuleProto::kJoinFieldNumber; +const int LineRuleProto::kCapFieldNumber; #endif // !_MSC_VER LineRuleProto::LineRuleProto() @@ -278,6 +535,7 @@ LineRuleProto::LineRuleProto() void LineRuleProto::InitAsDefaultInstance() { dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance()); + pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance()); } LineRuleProto::LineRuleProto(const LineRuleProto& from) @@ -292,6 +550,9 @@ void LineRuleProto::SharedCtor() { color_ = 0u; dashdot_ = NULL; priority_ = 0; + pathsym_ = NULL; + join_ = 0; + cap_ = 0; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } @@ -302,6 +563,7 @@ LineRuleProto::~LineRuleProto() { void LineRuleProto::SharedDtor() { if (this != default_instance_) { delete dashdot_; + delete pathsym_; } } @@ -328,6 +590,11 @@ void LineRuleProto::Clear() { if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear(); } priority_ = 0; + if (has_pathsym()) { + if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear(); + } + join_ = 0; + cap_ = 0; } ::memset(_has_bits_, 0, sizeof(_has_bits_)); } @@ -352,7 +619,7 @@ bool LineRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(16)) goto parse_color; break; } - + // required uint32 color = 2; case 2: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -368,7 +635,7 @@ bool LineRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(26)) goto parse_dashdot; break; } - + // optional .DashDotProto dashdot = 3; case 3: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -382,7 +649,7 @@ bool LineRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(32)) goto parse_priority; break; } - + // required int32 priority = 4; case 4: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -395,10 +662,62 @@ bool LineRuleProto::MergePartialFromCodedStream( } else { goto handle_uninterpreted; } + if (input->ExpectTag(42)) goto parse_pathsym; + break; + } + + // optional .PathSymProto pathsym = 5; + case 5: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_pathsym: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_pathsym())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_join; + break; + } + + // optional .LineJoin join = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_join: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (LineJoin_IsValid(value)) { + set_join(static_cast< LineJoin >(value)); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(56)) goto parse_cap; + break; + } + + // optional .LineCap cap = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_cap: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (LineCap_IsValid(value)) { + set_cap(static_cast< LineCap >(value)); + } + } else { + goto handle_uninterpreted; + } if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -420,55 +739,92 @@ void LineRuleProto::SerializeWithCachedSizes( if (has_width()) { ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->width(), output); } - + // required uint32 color = 2; if (has_color()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output); } - + // optional .DashDotProto dashdot = 3; if (has_dashdot()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 3, this->dashdot(), output); } - + // required int32 priority = 4; if (has_priority()) { ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output); } - + + // optional .PathSymProto pathsym = 5; + if (has_pathsym()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 5, this->pathsym(), output); + } + + // optional .LineJoin join = 6; + if (has_join()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->join(), output); + } + + // optional .LineCap cap = 7; + if (has_cap()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 7, this->cap(), 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 uint32 color = 2; if (has_color()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::UInt32Size( this->color()); } - + // optional .DashDotProto dashdot = 3; if (has_dashdot()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->dashdot()); } - + // required int32 priority = 4; if (has_priority()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::Int32Size( this->priority()); } - + + // optional .PathSymProto pathsym = 5; + if (has_pathsym()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->pathsym()); + } + + // optional .LineJoin join = 6; + if (has_join()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->join()); + } + + // optional .LineCap cap = 7; + if (has_cap()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap()); + } + } GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; @@ -496,6 +852,15 @@ void LineRuleProto::MergeFrom(const LineRuleProto& from) { if (from.has_priority()) { set_priority(from.priority()); } + if (from.has_pathsym()) { + mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym()); + } + if (from.has_join()) { + set_join(from.join()); + } + if (from.has_cap()) { + set_cap(from.cap()); + } } } @@ -507,7 +872,10 @@ void LineRuleProto::CopyFrom(const LineRuleProto& from) { bool LineRuleProto::IsInitialized() const { if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false; - + + if (has_pathsym()) { + if (!this->pathsym().IsInitialized()) return false; + } return true; } @@ -517,6 +885,9 @@ void LineRuleProto::Swap(LineRuleProto* other) { std::swap(color_, other->color_); std::swap(dashdot_, other->dashdot_); std::swap(priority_, other->priority_); + std::swap(pathsym_, other->pathsym_); + std::swap(join_, other->join_); + std::swap(cap_, other->cap_); std::swap(_has_bits_[0], other->_has_bits_[0]); std::swap(_cached_size_, other->_cached_size_); } @@ -533,6 +904,9 @@ void LineRuleProto::Swap(LineRuleProto* other) { const int LineDefProto::kWidthFieldNumber; const int LineDefProto::kColorFieldNumber; const int LineDefProto::kDashdotFieldNumber; +const int LineDefProto::kPathsymFieldNumber; +const int LineDefProto::kJoinFieldNumber; +const int LineDefProto::kCapFieldNumber; #endif // !_MSC_VER LineDefProto::LineDefProto() @@ -542,6 +916,7 @@ LineDefProto::LineDefProto() void LineDefProto::InitAsDefaultInstance() { dashdot_ = const_cast< ::DashDotProto*>(&::DashDotProto::default_instance()); + pathsym_ = const_cast< ::PathSymProto*>(&::PathSymProto::default_instance()); } LineDefProto::LineDefProto(const LineDefProto& from) @@ -555,6 +930,9 @@ void LineDefProto::SharedCtor() { width_ = 0; color_ = 0u; dashdot_ = NULL; + pathsym_ = NULL; + join_ = 0; + cap_ = 0; ::memset(_has_bits_, 0, sizeof(_has_bits_)); } @@ -565,6 +943,7 @@ LineDefProto::~LineDefProto() { void LineDefProto::SharedDtor() { if (this != default_instance_) { delete dashdot_; + delete pathsym_; } } @@ -590,6 +969,11 @@ void LineDefProto::Clear() { if (has_dashdot()) { if (dashdot_ != NULL) dashdot_->::DashDotProto::Clear(); } + if (has_pathsym()) { + if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear(); + } + join_ = 0; + cap_ = 0; } ::memset(_has_bits_, 0, sizeof(_has_bits_)); } @@ -614,7 +998,7 @@ bool LineDefProto::MergePartialFromCodedStream( if (input->ExpectTag(16)) goto parse_color; break; } - + // required uint32 color = 2; case 2: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -630,7 +1014,7 @@ bool LineDefProto::MergePartialFromCodedStream( if (input->ExpectTag(26)) goto parse_dashdot; break; } - + // optional .DashDotProto dashdot = 3; case 3: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -641,10 +1025,62 @@ bool LineDefProto::MergePartialFromCodedStream( } else { goto handle_uninterpreted; } + if (input->ExpectTag(34)) goto parse_pathsym; + break; + } + + // optional .PathSymProto pathsym = 4; + case 4: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) { + parse_pathsym: + DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual( + input, mutable_pathsym())); + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(48)) goto parse_join; + break; + } + + // optional .LineJoin join = 6; + case 6: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_join: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (LineJoin_IsValid(value)) { + set_join(static_cast< LineJoin >(value)); + } + } else { + goto handle_uninterpreted; + } + if (input->ExpectTag(56)) goto parse_cap; + break; + } + + // optional .LineCap cap = 7; + case 7: { + if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == + ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) { + parse_cap: + int value; + DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive< + int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>( + input, &value))); + if (LineCap_IsValid(value)) { + set_cap(static_cast< LineCap >(value)); + } + } else { + goto handle_uninterpreted; + } if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -666,43 +1102,80 @@ void LineDefProto::SerializeWithCachedSizes( if (has_width()) { ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->width(), output); } - + // required uint32 color = 2; if (has_color()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output); } - + // optional .DashDotProto dashdot = 3; if (has_dashdot()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 3, this->dashdot(), output); } - + + // optional .PathSymProto pathsym = 4; + if (has_pathsym()) { + ::google::protobuf::internal::WireFormatLite::WriteMessage( + 4, this->pathsym(), output); + } + + // optional .LineJoin join = 6; + if (has_join()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 6, this->join(), output); + } + + // optional .LineCap cap = 7; + if (has_cap()) { + ::google::protobuf::internal::WireFormatLite::WriteEnum( + 7, this->cap(), output); + } + } int LineDefProto::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 uint32 color = 2; if (has_color()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::UInt32Size( this->color()); } - + // optional .DashDotProto dashdot = 3; if (has_dashdot()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->dashdot()); } - + + // optional .PathSymProto pathsym = 4; + if (has_pathsym()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( + this->pathsym()); + } + + // optional .LineJoin join = 6; + if (has_join()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->join()); + } + + // optional .LineCap cap = 7; + if (has_cap()) { + total_size += 1 + + ::google::protobuf::internal::WireFormatLite::EnumSize(this->cap()); + } + } GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; @@ -727,6 +1200,15 @@ void LineDefProto::MergeFrom(const LineDefProto& from) { if (from.has_dashdot()) { mutable_dashdot()->::DashDotProto::MergeFrom(from.dashdot()); } + if (from.has_pathsym()) { + mutable_pathsym()->::PathSymProto::MergeFrom(from.pathsym()); + } + if (from.has_join()) { + set_join(from.join()); + } + if (from.has_cap()) { + set_cap(from.cap()); + } } } @@ -738,7 +1220,10 @@ void LineDefProto::CopyFrom(const LineDefProto& from) { bool LineDefProto::IsInitialized() const { if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; - + + if (has_pathsym()) { + if (!this->pathsym().IsInitialized()) return false; + } return true; } @@ -747,6 +1232,9 @@ void LineDefProto::Swap(LineDefProto* other) { std::swap(width_, other->width_); std::swap(color_, other->color_); std::swap(dashdot_, other->dashdot_); + std::swap(pathsym_, other->pathsym_); + std::swap(join_, other->join_); + std::swap(cap_, other->cap_); std::swap(_has_bits_[0], other->_has_bits_[0]); std::swap(_cached_size_, other->_cached_size_); } @@ -844,7 +1332,7 @@ bool AreaRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(18)) goto parse_border; break; } - + // optional .LineDefProto border = 2; case 2: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -858,7 +1346,7 @@ bool AreaRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(24)) goto parse_priority; break; } - + // required int32 priority = 3; case 3: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -874,7 +1362,7 @@ bool AreaRuleProto::MergePartialFromCodedStream( if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -896,23 +1384,23 @@ void AreaRuleProto::SerializeWithCachedSizes( if (has_color()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->color(), output); } - + // optional .LineDefProto border = 2; if (has_border()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 2, this->border(), output); } - + // required int32 priority = 3; if (has_priority()) { ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output); } - + } int AreaRuleProto::ByteSize() const { int total_size = 0; - + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { // required uint32 color = 1; if (has_color()) { @@ -920,21 +1408,21 @@ int AreaRuleProto::ByteSize() const { ::google::protobuf::internal::WireFormatLite::UInt32Size( this->color()); } - + // optional .LineDefProto border = 2; if (has_border()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->border()); } - + // required int32 priority = 3; if (has_priority()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::Int32Size( this->priority()); } - + } GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; @@ -970,7 +1458,7 @@ void AreaRuleProto::CopyFrom(const AreaRuleProto& from) { bool AreaRuleProto::IsInitialized() const { if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false; - + if (has_border()) { if (!this->border().IsInitialized()) return false; } @@ -1080,7 +1568,7 @@ bool SymbolRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(16)) goto parse_apply_for_type; break; } - + // optional int32 apply_for_type = 2; case 2: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1096,7 +1584,7 @@ bool SymbolRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(24)) goto parse_priority; break; } - + // required int32 priority = 3; case 3: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1112,7 +1600,7 @@ bool SymbolRuleProto::MergePartialFromCodedStream( if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1135,22 +1623,22 @@ void SymbolRuleProto::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteString( 1, this->name(), output); } - + // optional int32 apply_for_type = 2; if (has_apply_for_type()) { ::google::protobuf::internal::WireFormatLite::WriteInt32(2, this->apply_for_type(), output); } - + // required int32 priority = 3; if (has_priority()) { ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output); } - + } int SymbolRuleProto::ByteSize() const { int total_size = 0; - + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { // required string name = 1; if (has_name()) { @@ -1158,21 +1646,21 @@ int SymbolRuleProto::ByteSize() const { ::google::protobuf::internal::WireFormatLite::StringSize( this->name()); } - + // optional int32 apply_for_type = 2; if (has_apply_for_type()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::Int32Size( this->apply_for_type()); } - + // required int32 priority = 3; if (has_priority()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::Int32Size( this->priority()); } - + } GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; @@ -1208,7 +1696,7 @@ void SymbolRuleProto::CopyFrom(const SymbolRuleProto& from) { bool SymbolRuleProto::IsInitialized() const { if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false; - + return true; } @@ -1310,7 +1798,7 @@ bool CaptionDefProto::MergePartialFromCodedStream( if (input->ExpectTag(16)) goto parse_color; break; } - + // required uint32 color = 2; case 2: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1326,7 +1814,7 @@ bool CaptionDefProto::MergePartialFromCodedStream( if (input->ExpectTag(24)) goto parse_stroke_color; break; } - + // optional uint32 stroke_color = 3; case 3: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1342,7 +1830,7 @@ bool CaptionDefProto::MergePartialFromCodedStream( if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1364,22 +1852,22 @@ void CaptionDefProto::SerializeWithCachedSizes( if (has_height()) { ::google::protobuf::internal::WireFormatLite::WriteInt32(1, this->height(), output); } - + // required uint32 color = 2; if (has_color()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output); } - + // optional uint32 stroke_color = 3; if (has_stroke_color()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(3, this->stroke_color(), output); } - + } int CaptionDefProto::ByteSize() const { int total_size = 0; - + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { // required int32 height = 1; if (has_height()) { @@ -1387,21 +1875,21 @@ int CaptionDefProto::ByteSize() const { ::google::protobuf::internal::WireFormatLite::Int32Size( this->height()); } - + // required uint32 color = 2; if (has_color()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::UInt32Size( this->color()); } - + // optional uint32 stroke_color = 3; if (has_stroke_color()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::UInt32Size( this->stroke_color()); } - + } GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; @@ -1437,7 +1925,7 @@ void CaptionDefProto::CopyFrom(const CaptionDefProto& from) { bool CaptionDefProto::IsInitialized() const { if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false; - + return true; } @@ -1545,7 +2033,7 @@ bool CaptionRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(18)) goto parse_secondary; break; } - + // optional .CaptionDefProto secondary = 2; case 2: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1559,7 +2047,7 @@ bool CaptionRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(24)) goto parse_priority; break; } - + // required int32 priority = 3; case 3: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1575,7 +2063,7 @@ bool CaptionRuleProto::MergePartialFromCodedStream( if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1598,23 +2086,23 @@ void CaptionRuleProto::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteMessage( 1, this->primary(), output); } - + // optional .CaptionDefProto secondary = 2; if (has_secondary()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 2, this->secondary(), output); } - + // required int32 priority = 3; if (has_priority()) { ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output); } - + } int CaptionRuleProto::ByteSize() const { int total_size = 0; - + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { // required .CaptionDefProto primary = 1; if (has_primary()) { @@ -1622,21 +2110,21 @@ int CaptionRuleProto::ByteSize() const { ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->primary()); } - + // optional .CaptionDefProto secondary = 2; if (has_secondary()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->secondary()); } - + // required int32 priority = 3; if (has_priority()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::Int32Size( this->priority()); } - + } GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; @@ -1672,7 +2160,7 @@ void CaptionRuleProto::CopyFrom(const CaptionRuleProto& from) { bool CaptionRuleProto::IsInitialized() const { if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false; - + if (has_primary()) { if (!this->primary().IsInitialized()) return false; } @@ -1787,7 +2275,7 @@ bool CircleRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(16)) goto parse_color; break; } - + // required uint32 color = 2; case 2: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1803,7 +2291,7 @@ bool CircleRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(26)) goto parse_border; break; } - + // optional .LineDefProto border = 3; case 3: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1817,7 +2305,7 @@ bool CircleRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(32)) goto parse_priority; break; } - + // required int32 priority = 4; case 4: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1833,7 +2321,7 @@ bool CircleRuleProto::MergePartialFromCodedStream( if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -1855,55 +2343,55 @@ void CircleRuleProto::SerializeWithCachedSizes( if (has_radius()) { ::google::protobuf::internal::WireFormatLite::WriteDouble(1, this->radius(), output); } - + // required uint32 color = 2; if (has_color()) { ::google::protobuf::internal::WireFormatLite::WriteUInt32(2, this->color(), output); } - + // optional .LineDefProto border = 3; if (has_border()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 3, this->border(), output); } - + // required int32 priority = 4; if (has_priority()) { ::google::protobuf::internal::WireFormatLite::WriteInt32(4, this->priority(), output); } - + } int CircleRuleProto::ByteSize() const { int total_size = 0; - + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { // required double radius = 1; if (has_radius()) { total_size += 1 + 8; } - + // required uint32 color = 2; if (has_color()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::UInt32Size( this->color()); } - + // optional .LineDefProto border = 3; if (has_border()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->border()); } - + // required int32 priority = 4; if (has_priority()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::Int32Size( this->priority()); } - + } GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; @@ -1942,7 +2430,7 @@ void CircleRuleProto::CopyFrom(const CircleRuleProto& from) { bool CircleRuleProto::IsInitialized() const { if ((_has_bits_[0] & 0x0000000b) != 0x0000000b) return false; - + if (has_border()) { if (!this->border().IsInitialized()) return false; } @@ -2054,7 +2542,7 @@ bool PathTextRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(18)) goto parse_secondary; break; } - + // optional .CaptionDefProto secondary = 2; case 2: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2068,7 +2556,7 @@ bool PathTextRuleProto::MergePartialFromCodedStream( if (input->ExpectTag(24)) goto parse_priority; break; } - + // required int32 priority = 3; case 3: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2084,7 +2572,7 @@ bool PathTextRuleProto::MergePartialFromCodedStream( if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2107,23 +2595,23 @@ void PathTextRuleProto::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteMessage( 1, this->primary(), output); } - + // optional .CaptionDefProto secondary = 2; if (has_secondary()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 2, this->secondary(), output); } - + // required int32 priority = 3; if (has_priority()) { ::google::protobuf::internal::WireFormatLite::WriteInt32(3, this->priority(), output); } - + } int PathTextRuleProto::ByteSize() const { int total_size = 0; - + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { // required .CaptionDefProto primary = 1; if (has_primary()) { @@ -2131,21 +2619,21 @@ int PathTextRuleProto::ByteSize() const { ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->primary()); } - + // optional .CaptionDefProto secondary = 2; if (has_secondary()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->secondary()); } - + // required int32 priority = 3; if (has_priority()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::Int32Size( this->priority()); } - + } GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; @@ -2181,7 +2669,7 @@ void PathTextRuleProto::CopyFrom(const PathTextRuleProto& from) { bool PathTextRuleProto::IsInitialized() const { if ((_has_bits_[0] & 0x00000005) != 0x00000005) return false; - + if (has_primary()) { if (!this->primary().IsInitialized()) return false; } @@ -2320,7 +2808,7 @@ bool DrawElementProto::MergePartialFromCodedStream( if (input->ExpectTag(18)) goto parse_lines; break; } - + // repeated .LineRuleProto lines = 2; case 2: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2335,7 +2823,7 @@ bool DrawElementProto::MergePartialFromCodedStream( if (input->ExpectTag(26)) goto parse_area; break; } - + // optional .AreaRuleProto area = 3; case 3: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2349,7 +2837,7 @@ bool DrawElementProto::MergePartialFromCodedStream( if (input->ExpectTag(34)) goto parse_symbol; break; } - + // optional .SymbolRuleProto symbol = 4; case 4: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2363,7 +2851,7 @@ bool DrawElementProto::MergePartialFromCodedStream( if (input->ExpectTag(42)) goto parse_caption; break; } - + // optional .CaptionRuleProto caption = 5; case 5: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2377,7 +2865,7 @@ bool DrawElementProto::MergePartialFromCodedStream( if (input->ExpectTag(50)) goto parse_circle; break; } - + // optional .CircleRuleProto circle = 6; case 6: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2391,7 +2879,7 @@ bool DrawElementProto::MergePartialFromCodedStream( if (input->ExpectTag(58)) goto parse_path_text; break; } - + // optional .PathTextRuleProto path_text = 7; case 7: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2405,7 +2893,7 @@ bool DrawElementProto::MergePartialFromCodedStream( if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2427,48 +2915,48 @@ void DrawElementProto::SerializeWithCachedSizes( 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 symbol = 4; if (has_symbol()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 4, this->symbol(), output); } - + // optional .CaptionRuleProto caption = 5; if (has_caption()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 5, this->caption(), output); } - + // optional .CircleRuleProto circle = 6; if (has_circle()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 6, this->circle(), output); } - + // optional .PathTextRuleProto path_text = 7; if (has_path_text()) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 7, this->path_text(), output); } - + } int DrawElementProto::ByteSize() const { int total_size = 0; - + if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) { // required int32 scale = 1; if (has_scale()) { @@ -2476,42 +2964,42 @@ int DrawElementProto::ByteSize() const { ::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 symbol = 4; if (has_symbol()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->symbol()); } - + // optional .CaptionRuleProto caption = 5; if (has_caption()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->caption()); } - + // optional .CircleRuleProto circle = 6; if (has_circle()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->circle()); } - + // optional .PathTextRuleProto path_text = 7; if (has_path_text()) { total_size += 1 + ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->path_text()); } - + } // repeated .LineRuleProto lines = 2; total_size += 1 * this->lines_size(); @@ -2520,7 +3008,7 @@ int DrawElementProto::ByteSize() const { ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->lines(i)); } - + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -2565,7 +3053,7 @@ void DrawElementProto::CopyFrom(const DrawElementProto& 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; } @@ -2690,7 +3178,7 @@ bool ClassifElementProto::MergePartialFromCodedStream( if (input->ExpectTag(18)) goto parse_element; break; } - + // repeated .DrawElementProto element = 2; case 2: { if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2705,7 +3193,7 @@ bool ClassifElementProto::MergePartialFromCodedStream( if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2728,18 +3216,18 @@ void ClassifElementProto::SerializeWithCachedSizes( ::google::protobuf::internal::WireFormatLite::WriteString( 1, this->name(), output); } - + // repeated .DrawElementProto element = 2; for (int i = 0; i < this->element_size(); i++) { ::google::protobuf::internal::WireFormatLite::WriteMessage( 2, this->element(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()) { @@ -2747,7 +3235,7 @@ int ClassifElementProto::ByteSize() const { ::google::protobuf::internal::WireFormatLite::StringSize( this->name()); } - + } // repeated .DrawElementProto element = 2; total_size += 1 * this->element_size(); @@ -2756,7 +3244,7 @@ int ClassifElementProto::ByteSize() const { ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->element(i)); } - + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -2786,7 +3274,7 @@ void ClassifElementProto::CopyFrom(const ClassifElementProto& from) { bool ClassifElementProto::IsInitialized() const { if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false; - + for (int i = 0; i < element_size(); i++) { if (!this->element(i).IsInitialized()) return false; } @@ -2881,7 +3369,7 @@ bool ContainerProto::MergePartialFromCodedStream( if (input->ExpectAtEnd()) return true; break; } - + default: { handle_uninterpreted: if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) == @@ -2904,12 +3392,12 @@ void ContainerProto::SerializeWithCachedSizes( ::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++) { @@ -2917,7 +3405,7 @@ int ContainerProto::ByteSize() const { ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual( this->cont(i)); } - + GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN(); _cached_size_ = total_size; GOOGLE_SAFE_CONCURRENT_WRITES_END(); @@ -2941,7 +3429,7 @@ void ContainerProto::CopyFrom(const ContainerProto& from) { } bool ContainerProto::IsInitialized() const { - + for (int i = 0; i < cont_size(); i++) { if (!this->cont(i).IsInitialized()) return false; } diff --git a/indexer/drules_struct_lite.pb.h b/indexer/drules_struct_lite.pb.h index 38b11b5d7c..f7de5bbe9f 100644 --- a/indexer/drules_struct_lite.pb.h +++ b/indexer/drules_struct_lite.pb.h @@ -30,6 +30,7 @@ void protobuf_AssignDesc_drules_5fstruct_2eproto(); void protobuf_ShutdownFile_drules_5fstruct_2eproto(); class DashDotProto; +class PathSymProto; class LineRuleProto; class LineDefProto; class AreaRuleProto; @@ -42,33 +43,51 @@ class DrawElementProto; class ClassifElementProto; class ContainerProto; +enum LineJoin { + ROUNDJOIN = 0, + BEVELJOIN = 1 +}; +bool LineJoin_IsValid(int value); +const LineJoin LineJoin_MIN = ROUNDJOIN; +const LineJoin LineJoin_MAX = BEVELJOIN; +const int LineJoin_ARRAYSIZE = LineJoin_MAX + 1; + +enum LineCap { + ROUNDCAP = 0, + BUTTCAP = 1 +}; +bool LineCap_IsValid(int value); +const LineCap LineCap_MIN = ROUNDCAP; +const LineCap LineCap_MAX = BUTTCAP; +const int LineCap_ARRAYSIZE = LineCap_MAX + 1; + // =================================================================== 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); @@ -80,13 +99,13 @@ class DashDotProto : public ::google::protobuf::MessageLite { 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(); @@ -98,59 +117,59 @@ class DashDotProto : public ::google::protobuf::MessageLite { dd() const; inline ::google::protobuf::RepeatedField< double >* mutable_dd(); - + // optional double offset = 2; inline bool has_offset() const; inline void clear_offset(); static const int kOffsetFieldNumber = 2; inline double offset() const; inline void set_offset(double value); - + // @@protoc_insertion_point(class_scope:DashDotProto) private: inline void set_has_offset(); inline void clear_has_offset(); - + ::google::protobuf::RepeatedField< double > dd_; double offset_; - + 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 DashDotProto* default_instance_; }; // ------------------------------------------------------------------- -class LineRuleProto : public ::google::protobuf::MessageLite { +class PathSymProto : public ::google::protobuf::MessageLite { public: - LineRuleProto(); - virtual ~LineRuleProto(); - - LineRuleProto(const LineRuleProto& from); - - inline LineRuleProto& operator=(const LineRuleProto& from) { + PathSymProto(); + virtual ~PathSymProto(); + + PathSymProto(const PathSymProto& from); + + inline PathSymProto& operator=(const PathSymProto& from) { CopyFrom(from); return *this; } - - static const LineRuleProto& default_instance(); - - void Swap(LineRuleProto* other); - + + static const PathSymProto& default_instance(); + + void Swap(PathSymProto* other); + // implements Message ---------------------------------------------- - - LineRuleProto* New() const; + + PathSymProto* New() const; void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); - void CopyFrom(const LineRuleProto& from); - void MergeFrom(const LineRuleProto& from); + void CopyFrom(const PathSymProto& from); + void MergeFrom(const PathSymProto& from); void Clear(); bool IsInitialized() const; - + int ByteSize() const; bool MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input); @@ -162,293 +181,13 @@ class LineRuleProto : public ::google::protobuf::MessageLite { 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 uint32 color = 2; - inline bool has_color() const; - inline void clear_color(); - static const int kColorFieldNumber = 2; - inline ::google::protobuf::uint32 color() const; - inline void set_color(::google::protobuf::uint32 value); - - // 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(); - - // required int32 priority = 4; - inline bool has_priority() const; - inline void clear_priority(); - static const int kPriorityFieldNumber = 4; - inline ::google::protobuf::int32 priority() const; - inline void set_priority(::google::protobuf::int32 value); - - // @@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(); - inline void set_has_priority(); - inline void clear_has_priority(); - - double width_; - ::DashDotProto* dashdot_; - ::google::protobuf::uint32 color_; - ::google::protobuf::int32 priority_; - - mutable int _cached_size_; - ::google::protobuf::uint32 _has_bits_[(4 + 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 LineDefProto : public ::google::protobuf::MessageLite { - public: - LineDefProto(); - virtual ~LineDefProto(); - - LineDefProto(const LineDefProto& from); - - inline LineDefProto& operator=(const LineDefProto& from) { - CopyFrom(from); - return *this; - } - - static const LineDefProto& default_instance(); - - void Swap(LineDefProto* other); - - // implements Message ---------------------------------------------- - - LineDefProto* New() const; - void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); - void CopyFrom(const LineDefProto& from); - void MergeFrom(const LineDefProto& 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 uint32 color = 2; - inline bool has_color() const; - inline void clear_color(); - static const int kColorFieldNumber = 2; - inline ::google::protobuf::uint32 color() const; - inline void set_color(::google::protobuf::uint32 value); - - // 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:LineDefProto) - 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_; - ::DashDotProto* dashdot_; - ::google::protobuf::uint32 color_; - - 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 LineDefProto* 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 uint32 color = 1; - inline bool has_color() const; - inline void clear_color(); - static const int kColorFieldNumber = 1; - inline ::google::protobuf::uint32 color() const; - inline void set_color(::google::protobuf::uint32 value); - - // optional .LineDefProto border = 2; - inline bool has_border() const; - inline void clear_border(); - static const int kBorderFieldNumber = 2; - inline const ::LineDefProto& border() const; - inline ::LineDefProto* mutable_border(); - inline ::LineDefProto* release_border(); - - // required int32 priority = 3; - inline bool has_priority() const; - inline void clear_priority(); - static const int kPriorityFieldNumber = 3; - inline ::google::protobuf::int32 priority() const; - inline void set_priority(::google::protobuf::int32 value); - - // @@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(); - inline void set_has_priority(); - inline void clear_has_priority(); - - ::LineDefProto* border_; - ::google::protobuf::uint32 color_; - ::google::protobuf::int32 priority_; - - 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 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(); @@ -459,21 +198,456 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite { inline void set_name(const char* value, size_t size); inline ::std::string* mutable_name(); inline ::std::string* release_name(); + + // required double step = 2; + inline bool has_step() const; + inline void clear_step(); + static const int kStepFieldNumber = 2; + inline double step() const; + inline void set_step(double value); + + // optional double offset = 3; + inline bool has_offset() const; + inline void clear_offset(); + static const int kOffsetFieldNumber = 3; + inline double offset() const; + inline void set_offset(double value); + + // @@protoc_insertion_point(class_scope:PathSymProto) + private: + inline void set_has_name(); + inline void clear_has_name(); + inline void set_has_step(); + inline void clear_has_step(); + inline void set_has_offset(); + inline void clear_has_offset(); + + ::std::string* name_; + double step_; + double offset_; + + 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 PathSymProto* default_instance_; +}; +// ------------------------------------------------------------------- - // optional int32 apply_for_type = 2; - inline bool has_apply_for_type() const; - inline void clear_apply_for_type(); - static const int kApplyForTypeFieldNumber = 2; - inline ::google::protobuf::int32 apply_for_type() const; - inline void set_apply_for_type(::google::protobuf::int32 value); +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 uint32 color = 2; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 2; + inline ::google::protobuf::uint32 color() const; + inline void set_color(::google::protobuf::uint32 value); + + // 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(); + + // required int32 priority = 4; + inline bool has_priority() const; + inline void clear_priority(); + static const int kPriorityFieldNumber = 4; + inline ::google::protobuf::int32 priority() const; + inline void set_priority(::google::protobuf::int32 value); + + // optional .PathSymProto pathsym = 5; + inline bool has_pathsym() const; + inline void clear_pathsym(); + static const int kPathsymFieldNumber = 5; + inline const ::PathSymProto& pathsym() const; + inline ::PathSymProto* mutable_pathsym(); + inline ::PathSymProto* release_pathsym(); + + // optional .LineJoin join = 6; + inline bool has_join() const; + inline void clear_join(); + static const int kJoinFieldNumber = 6; + inline LineJoin join() const; + inline void set_join(LineJoin value); + + // optional .LineCap cap = 7; + inline bool has_cap() const; + inline void clear_cap(); + static const int kCapFieldNumber = 7; + inline LineCap cap() const; + inline void set_cap(LineCap value); + + // @@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(); + inline void set_has_priority(); + inline void clear_has_priority(); + inline void set_has_pathsym(); + inline void clear_has_pathsym(); + inline void set_has_join(); + inline void clear_has_join(); + inline void set_has_cap(); + inline void clear_has_cap(); + + double width_; + ::DashDotProto* dashdot_; + ::google::protobuf::uint32 color_; + ::google::protobuf::int32 priority_; + ::PathSymProto* pathsym_; + int join_; + int cap_; + + mutable int _cached_size_; + ::google::protobuf::uint32 _has_bits_[(7 + 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 LineDefProto : public ::google::protobuf::MessageLite { + public: + LineDefProto(); + virtual ~LineDefProto(); + + LineDefProto(const LineDefProto& from); + + inline LineDefProto& operator=(const LineDefProto& from) { + CopyFrom(from); + return *this; + } + + static const LineDefProto& default_instance(); + + void Swap(LineDefProto* other); + + // implements Message ---------------------------------------------- + + LineDefProto* New() const; + void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); + void CopyFrom(const LineDefProto& from); + void MergeFrom(const LineDefProto& 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 uint32 color = 2; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 2; + inline ::google::protobuf::uint32 color() const; + inline void set_color(::google::protobuf::uint32 value); + + // 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(); + + // optional .PathSymProto pathsym = 4; + inline bool has_pathsym() const; + inline void clear_pathsym(); + static const int kPathsymFieldNumber = 4; + inline const ::PathSymProto& pathsym() const; + inline ::PathSymProto* mutable_pathsym(); + inline ::PathSymProto* release_pathsym(); + + // optional .LineJoin join = 6; + inline bool has_join() const; + inline void clear_join(); + static const int kJoinFieldNumber = 6; + inline LineJoin join() const; + inline void set_join(LineJoin value); + + // optional .LineCap cap = 7; + inline bool has_cap() const; + inline void clear_cap(); + static const int kCapFieldNumber = 7; + inline LineCap cap() const; + inline void set_cap(LineCap value); + + // @@protoc_insertion_point(class_scope:LineDefProto) + 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(); + inline void set_has_pathsym(); + inline void clear_has_pathsym(); + inline void set_has_join(); + inline void clear_has_join(); + inline void set_has_cap(); + inline void clear_has_cap(); + + double width_; + ::DashDotProto* dashdot_; + ::google::protobuf::uint32 color_; + int join_; + ::PathSymProto* pathsym_; + int cap_; + + 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 LineDefProto* 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 uint32 color = 1; + inline bool has_color() const; + inline void clear_color(); + static const int kColorFieldNumber = 1; + inline ::google::protobuf::uint32 color() const; + inline void set_color(::google::protobuf::uint32 value); + + // optional .LineDefProto border = 2; + inline bool has_border() const; + inline void clear_border(); + static const int kBorderFieldNumber = 2; + inline const ::LineDefProto& border() const; + inline ::LineDefProto* mutable_border(); + inline ::LineDefProto* release_border(); + // required int32 priority = 3; inline bool has_priority() const; inline void clear_priority(); static const int kPriorityFieldNumber = 3; inline ::google::protobuf::int32 priority() const; inline void set_priority(::google::protobuf::int32 value); + + // @@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(); + inline void set_has_priority(); + inline void clear_has_priority(); + + ::LineDefProto* border_; + ::google::protobuf::uint32 color_; + ::google::protobuf::int32 priority_; + + 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 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(); + + // optional int32 apply_for_type = 2; + inline bool has_apply_for_type() const; + inline void clear_apply_for_type(); + static const int kApplyForTypeFieldNumber = 2; + inline ::google::protobuf::int32 apply_for_type() const; + inline void set_apply_for_type(::google::protobuf::int32 value); + + // required int32 priority = 3; + inline bool has_priority() const; + inline void clear_priority(); + static const int kPriorityFieldNumber = 3; + inline ::google::protobuf::int32 priority() const; + inline void set_priority(::google::protobuf::int32 value); + // @@protoc_insertion_point(class_scope:SymbolRuleProto) private: inline void set_has_name(); @@ -482,18 +656,18 @@ class SymbolRuleProto : public ::google::protobuf::MessageLite { inline void clear_has_apply_for_type(); inline void set_has_priority(); inline void clear_has_priority(); - + ::std::string* name_; ::google::protobuf::int32 apply_for_type_; ::google::protobuf::int32 priority_; - + 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 SymbolRuleProto* default_instance_; }; @@ -503,27 +677,27 @@ class CaptionDefProto : public ::google::protobuf::MessageLite { public: CaptionDefProto(); virtual ~CaptionDefProto(); - + CaptionDefProto(const CaptionDefProto& from); - + inline CaptionDefProto& operator=(const CaptionDefProto& from) { CopyFrom(from); return *this; } - + static const CaptionDefProto& default_instance(); - + void Swap(CaptionDefProto* other); - + // implements Message ---------------------------------------------- - + CaptionDefProto* New() const; void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); void CopyFrom(const CaptionDefProto& from); void MergeFrom(const CaptionDefProto& from); void Clear(); bool IsInitialized() const; - + int ByteSize() const; bool MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input); @@ -535,34 +709,34 @@ class CaptionDefProto : public ::google::protobuf::MessageLite { 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); - + // required uint32 color = 2; inline bool has_color() const; inline void clear_color(); static const int kColorFieldNumber = 2; inline ::google::protobuf::uint32 color() const; inline void set_color(::google::protobuf::uint32 value); - + // optional uint32 stroke_color = 3; inline bool has_stroke_color() const; inline void clear_stroke_color(); static const int kStrokeColorFieldNumber = 3; inline ::google::protobuf::uint32 stroke_color() const; inline void set_stroke_color(::google::protobuf::uint32 value); - + // @@protoc_insertion_point(class_scope:CaptionDefProto) private: inline void set_has_height(); @@ -571,18 +745,18 @@ class CaptionDefProto : public ::google::protobuf::MessageLite { inline void clear_has_color(); inline void set_has_stroke_color(); inline void clear_has_stroke_color(); - + ::google::protobuf::int32 height_; ::google::protobuf::uint32 color_; ::google::protobuf::uint32 stroke_color_; - + 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 CaptionDefProto* default_instance_; }; @@ -592,27 +766,27 @@ 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); @@ -624,13 +798,13 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite { void SharedDtor(); void SetCachedSize(int size) const; public: - + ::std::string GetTypeName() const; - + // nested types ---------------------------------------------------- - + // accessors ------------------------------------------------------- - + // required .CaptionDefProto primary = 1; inline bool has_primary() const; inline void clear_primary(); @@ -638,7 +812,7 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite { inline const ::CaptionDefProto& primary() const; inline ::CaptionDefProto* mutable_primary(); inline ::CaptionDefProto* release_primary(); - + // optional .CaptionDefProto secondary = 2; inline bool has_secondary() const; inline void clear_secondary(); @@ -646,14 +820,14 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite { inline const ::CaptionDefProto& secondary() const; inline ::CaptionDefProto* mutable_secondary(); inline ::CaptionDefProto* release_secondary(); - + // required int32 priority = 3; inline bool has_priority() const; inline void clear_priority(); static const int kPriorityFieldNumber = 3; inline ::google::protobuf::int32 priority() const; inline void set_priority(::google::protobuf::int32 value); - + // @@protoc_insertion_point(class_scope:CaptionRuleProto) private: inline void set_has_primary(); @@ -662,18 +836,18 @@ class CaptionRuleProto : public ::google::protobuf::MessageLite { inline void clear_has_secondary(); inline void set_has_priority(); inline void clear_has_priority(); - + ::CaptionDefProto* primary_; ::CaptionDefProto* secondary_; ::google::protobuf::int32 priority_; - + 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_; }; @@ -683,27 +857,27 @@ 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); @@ -715,27 +889,27 @@ class CircleRuleProto : public ::google::protobuf::MessageLite { void SharedDtor(); void SetCachedSize(int size) const; public: - + ::std::string GetTypeName() const; - + // nested types ---------------------------------------------------- - + // accessors ------------------------------------------------------- - + // required double radius = 1; inline bool has_radius() const; inline void clear_radius(); static const int kRadiusFieldNumber = 1; inline double radius() const; inline void set_radius(double value); - + // required uint32 color = 2; inline bool has_color() const; inline void clear_color(); static const int kColorFieldNumber = 2; inline ::google::protobuf::uint32 color() const; inline void set_color(::google::protobuf::uint32 value); - + // optional .LineDefProto border = 3; inline bool has_border() const; inline void clear_border(); @@ -743,14 +917,14 @@ class CircleRuleProto : public ::google::protobuf::MessageLite { inline const ::LineDefProto& border() const; inline ::LineDefProto* mutable_border(); inline ::LineDefProto* release_border(); - + // required int32 priority = 4; inline bool has_priority() const; inline void clear_priority(); static const int kPriorityFieldNumber = 4; inline ::google::protobuf::int32 priority() const; inline void set_priority(::google::protobuf::int32 value); - + // @@protoc_insertion_point(class_scope:CircleRuleProto) private: inline void set_has_radius(); @@ -761,19 +935,19 @@ class CircleRuleProto : public ::google::protobuf::MessageLite { inline void clear_has_border(); inline void set_has_priority(); inline void clear_has_priority(); - + double radius_; ::LineDefProto* border_; ::google::protobuf::uint32 color_; ::google::protobuf::int32 priority_; - + mutable int _cached_size_; ::google::protobuf::uint32 _has_bits_[(4 + 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_; }; @@ -783,27 +957,27 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite { public: PathTextRuleProto(); virtual ~PathTextRuleProto(); - + PathTextRuleProto(const PathTextRuleProto& from); - + inline PathTextRuleProto& operator=(const PathTextRuleProto& from) { CopyFrom(from); return *this; } - + static const PathTextRuleProto& default_instance(); - + void Swap(PathTextRuleProto* other); - + // implements Message ---------------------------------------------- - + PathTextRuleProto* New() const; void CheckTypeAndMergeFrom(const ::google::protobuf::MessageLite& from); void CopyFrom(const PathTextRuleProto& from); void MergeFrom(const PathTextRuleProto& from); void Clear(); bool IsInitialized() const; - + int ByteSize() const; bool MergePartialFromCodedStream( ::google::protobuf::io::CodedInputStream* input); @@ -815,13 +989,13 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite { void SharedDtor(); void SetCachedSize(int size) const; public: - + ::std::string GetTypeName() const; - + // nested types ---------------------------------------------------- - + // accessors ------------------------------------------------------- - + // required .CaptionDefProto primary = 1; inline bool has_primary() const; inline void clear_primary(); @@ -829,7 +1003,7 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite { inline const ::CaptionDefProto& primary() const; inline ::CaptionDefProto* mutable_primary(); inline ::CaptionDefProto* release_primary(); - + // optional .CaptionDefProto secondary = 2; inline bool has_secondary() const; inline void clear_secondary(); @@ -837,14 +1011,14 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite { inline const ::CaptionDefProto& secondary() const; inline ::CaptionDefProto* mutable_secondary(); inline ::CaptionDefProto* release_secondary(); - + // required int32 priority = 3; inline bool has_priority() const; inline void clear_priority(); static const int kPriorityFieldNumber = 3; inline ::google::protobuf::int32 priority() const; inline void set_priority(::google::protobuf::int32 value); - + // @@protoc_insertion_point(class_scope:PathTextRuleProto) private: inline void set_has_primary(); @@ -853,18 +1027,18 @@ class PathTextRuleProto : public ::google::protobuf::MessageLite { inline void clear_has_secondary(); inline void set_has_priority(); inline void clear_has_priority(); - + ::CaptionDefProto* primary_; ::CaptionDefProto* secondary_; ::google::protobuf::int32 priority_; - + 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 PathTextRuleProto* default_instance_; }; @@ -874,27 +1048,27 @@ 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); @@ -906,20 +1080,20 @@ class DrawElementProto : public ::google::protobuf::MessageLite { 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(); @@ -931,7 +1105,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite { lines() const; inline ::google::protobuf::RepeatedPtrField< ::LineRuleProto >* mutable_lines(); - + // optional .AreaRuleProto area = 3; inline bool has_area() const; inline void clear_area(); @@ -939,7 +1113,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite { inline const ::AreaRuleProto& area() const; inline ::AreaRuleProto* mutable_area(); inline ::AreaRuleProto* release_area(); - + // optional .SymbolRuleProto symbol = 4; inline bool has_symbol() const; inline void clear_symbol(); @@ -947,7 +1121,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite { inline const ::SymbolRuleProto& symbol() const; inline ::SymbolRuleProto* mutable_symbol(); inline ::SymbolRuleProto* release_symbol(); - + // optional .CaptionRuleProto caption = 5; inline bool has_caption() const; inline void clear_caption(); @@ -955,7 +1129,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite { inline const ::CaptionRuleProto& caption() const; inline ::CaptionRuleProto* mutable_caption(); inline ::CaptionRuleProto* release_caption(); - + // optional .CircleRuleProto circle = 6; inline bool has_circle() const; inline void clear_circle(); @@ -963,7 +1137,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite { inline const ::CircleRuleProto& circle() const; inline ::CircleRuleProto* mutable_circle(); inline ::CircleRuleProto* release_circle(); - + // optional .PathTextRuleProto path_text = 7; inline bool has_path_text() const; inline void clear_path_text(); @@ -971,7 +1145,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite { inline const ::PathTextRuleProto& path_text() const; inline ::PathTextRuleProto* mutable_path_text(); inline ::PathTextRuleProto* release_path_text(); - + // @@protoc_insertion_point(class_scope:DrawElementProto) private: inline void set_has_scale(); @@ -986,7 +1160,7 @@ class DrawElementProto : public ::google::protobuf::MessageLite { inline void clear_has_circle(); inline void set_has_path_text(); inline void clear_has_path_text(); - + ::google::protobuf::RepeatedPtrField< ::LineRuleProto > lines_; ::AreaRuleProto* area_; ::SymbolRuleProto* symbol_; @@ -994,14 +1168,14 @@ class DrawElementProto : public ::google::protobuf::MessageLite { ::CircleRuleProto* circle_; ::PathTextRuleProto* path_text_; ::google::protobuf::int32 scale_; - + mutable int _cached_size_; ::google::protobuf::uint32 _has_bits_[(7 + 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_; }; @@ -1011,27 +1185,27 @@ 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); @@ -1043,13 +1217,13 @@ class ClassifElementProto : public ::google::protobuf::MessageLite { 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(); @@ -1060,7 +1234,7 @@ class ClassifElementProto : public ::google::protobuf::MessageLite { inline void set_name(const char* value, size_t size); inline ::std::string* mutable_name(); inline ::std::string* release_name(); - + // repeated .DrawElementProto element = 2; inline int element_size() const; inline void clear_element(); @@ -1072,22 +1246,22 @@ class ClassifElementProto : public ::google::protobuf::MessageLite { element() const; inline ::google::protobuf::RepeatedPtrField< ::DrawElementProto >* mutable_element(); - + // @@protoc_insertion_point(class_scope:ClassifElementProto) private: inline void set_has_name(); inline void clear_has_name(); - + ::std::string* name_; ::google::protobuf::RepeatedPtrField< ::DrawElementProto > element_; - + 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_; }; @@ -1097,27 +1271,27 @@ 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); @@ -1129,13 +1303,13 @@ class ContainerProto : public ::google::protobuf::MessageLite { 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(); @@ -1147,19 +1321,19 @@ class ContainerProto : public ::google::protobuf::MessageLite { 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_; }; @@ -1219,6 +1393,112 @@ inline void DashDotProto::set_offset(double value) { // ------------------------------------------------------------------- +// PathSymProto + +// required string name = 1; +inline bool PathSymProto::has_name() const { + return (_has_bits_[0] & 0x00000001u) != 0; +} +inline void PathSymProto::set_has_name() { + _has_bits_[0] |= 0x00000001u; +} +inline void PathSymProto::clear_has_name() { + _has_bits_[0] &= ~0x00000001u; +} +inline void PathSymProto::clear_name() { + if (name_ != &::google::protobuf::internal::kEmptyString) { + name_->clear(); + } + clear_has_name(); +} +inline const ::std::string& PathSymProto::name() const { + return *name_; +} +inline void PathSymProto::set_name(const ::std::string& value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void PathSymProto::set_name(const char* value) { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + name_->assign(value); +} +inline void PathSymProto::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* PathSymProto::mutable_name() { + set_has_name(); + if (name_ == &::google::protobuf::internal::kEmptyString) { + name_ = new ::std::string; + } + return name_; +} +inline ::std::string* PathSymProto::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; + } +} + +// required double step = 2; +inline bool PathSymProto::has_step() const { + return (_has_bits_[0] & 0x00000002u) != 0; +} +inline void PathSymProto::set_has_step() { + _has_bits_[0] |= 0x00000002u; +} +inline void PathSymProto::clear_has_step() { + _has_bits_[0] &= ~0x00000002u; +} +inline void PathSymProto::clear_step() { + step_ = 0; + clear_has_step(); +} +inline double PathSymProto::step() const { + return step_; +} +inline void PathSymProto::set_step(double value) { + set_has_step(); + step_ = value; +} + +// optional double offset = 3; +inline bool PathSymProto::has_offset() const { + return (_has_bits_[0] & 0x00000004u) != 0; +} +inline void PathSymProto::set_has_offset() { + _has_bits_[0] |= 0x00000004u; +} +inline void PathSymProto::clear_has_offset() { + _has_bits_[0] &= ~0x00000004u; +} +inline void PathSymProto::clear_offset() { + offset_ = 0; + clear_has_offset(); +} +inline double PathSymProto::offset() const { + return offset_; +} +inline void PathSymProto::set_offset(double value) { + set_has_offset(); + offset_ = value; +} + +// ------------------------------------------------------------------- + // LineRuleProto // required double width = 1; @@ -1316,6 +1596,81 @@ inline void LineRuleProto::set_priority(::google::protobuf::int32 value) { priority_ = value; } +// optional .PathSymProto pathsym = 5; +inline bool LineRuleProto::has_pathsym() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void LineRuleProto::set_has_pathsym() { + _has_bits_[0] |= 0x00000010u; +} +inline void LineRuleProto::clear_has_pathsym() { + _has_bits_[0] &= ~0x00000010u; +} +inline void LineRuleProto::clear_pathsym() { + if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear(); + clear_has_pathsym(); +} +inline const ::PathSymProto& LineRuleProto::pathsym() const { + return pathsym_ != NULL ? *pathsym_ : *default_instance_->pathsym_; +} +inline ::PathSymProto* LineRuleProto::mutable_pathsym() { + set_has_pathsym(); + if (pathsym_ == NULL) pathsym_ = new ::PathSymProto; + return pathsym_; +} +inline ::PathSymProto* LineRuleProto::release_pathsym() { + clear_has_pathsym(); + ::PathSymProto* temp = pathsym_; + pathsym_ = NULL; + return temp; +} + +// optional .LineJoin join = 6; +inline bool LineRuleProto::has_join() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void LineRuleProto::set_has_join() { + _has_bits_[0] |= 0x00000020u; +} +inline void LineRuleProto::clear_has_join() { + _has_bits_[0] &= ~0x00000020u; +} +inline void LineRuleProto::clear_join() { + join_ = 0; + clear_has_join(); +} +inline LineJoin LineRuleProto::join() const { + return static_cast< LineJoin >(join_); +} +inline void LineRuleProto::set_join(LineJoin value) { + GOOGLE_DCHECK(LineJoin_IsValid(value)); + set_has_join(); + join_ = value; +} + +// optional .LineCap cap = 7; +inline bool LineRuleProto::has_cap() const { + return (_has_bits_[0] & 0x00000040u) != 0; +} +inline void LineRuleProto::set_has_cap() { + _has_bits_[0] |= 0x00000040u; +} +inline void LineRuleProto::clear_has_cap() { + _has_bits_[0] &= ~0x00000040u; +} +inline void LineRuleProto::clear_cap() { + cap_ = 0; + clear_has_cap(); +} +inline LineCap LineRuleProto::cap() const { + return static_cast< LineCap >(cap_); +} +inline void LineRuleProto::set_cap(LineCap value) { + GOOGLE_DCHECK(LineCap_IsValid(value)); + set_has_cap(); + cap_ = value; +} + // ------------------------------------------------------------------- // LineDefProto @@ -1393,6 +1748,81 @@ inline ::DashDotProto* LineDefProto::release_dashdot() { return temp; } +// optional .PathSymProto pathsym = 4; +inline bool LineDefProto::has_pathsym() const { + return (_has_bits_[0] & 0x00000008u) != 0; +} +inline void LineDefProto::set_has_pathsym() { + _has_bits_[0] |= 0x00000008u; +} +inline void LineDefProto::clear_has_pathsym() { + _has_bits_[0] &= ~0x00000008u; +} +inline void LineDefProto::clear_pathsym() { + if (pathsym_ != NULL) pathsym_->::PathSymProto::Clear(); + clear_has_pathsym(); +} +inline const ::PathSymProto& LineDefProto::pathsym() const { + return pathsym_ != NULL ? *pathsym_ : *default_instance_->pathsym_; +} +inline ::PathSymProto* LineDefProto::mutable_pathsym() { + set_has_pathsym(); + if (pathsym_ == NULL) pathsym_ = new ::PathSymProto; + return pathsym_; +} +inline ::PathSymProto* LineDefProto::release_pathsym() { + clear_has_pathsym(); + ::PathSymProto* temp = pathsym_; + pathsym_ = NULL; + return temp; +} + +// optional .LineJoin join = 6; +inline bool LineDefProto::has_join() const { + return (_has_bits_[0] & 0x00000010u) != 0; +} +inline void LineDefProto::set_has_join() { + _has_bits_[0] |= 0x00000010u; +} +inline void LineDefProto::clear_has_join() { + _has_bits_[0] &= ~0x00000010u; +} +inline void LineDefProto::clear_join() { + join_ = 0; + clear_has_join(); +} +inline LineJoin LineDefProto::join() const { + return static_cast< LineJoin >(join_); +} +inline void LineDefProto::set_join(LineJoin value) { + GOOGLE_DCHECK(LineJoin_IsValid(value)); + set_has_join(); + join_ = value; +} + +// optional .LineCap cap = 7; +inline bool LineDefProto::has_cap() const { + return (_has_bits_[0] & 0x00000020u) != 0; +} +inline void LineDefProto::set_has_cap() { + _has_bits_[0] |= 0x00000020u; +} +inline void LineDefProto::clear_has_cap() { + _has_bits_[0] &= ~0x00000020u; +} +inline void LineDefProto::clear_cap() { + cap_ = 0; + clear_has_cap(); +} +inline LineCap LineDefProto::cap() const { + return static_cast< LineCap >(cap_); +} +inline void LineDefProto::set_cap(LineCap value) { + GOOGLE_DCHECK(LineCap_IsValid(value)); + set_has_cap(); + cap_ = value; +} + // ------------------------------------------------------------------- // AreaRuleProto diff --git a/map/proto_to_styles.cpp b/map/proto_to_styles.cpp index a5054a553f..482a047196 100644 --- a/map/proto_to_styles.cpp +++ b/map/proto_to_styles.cpp @@ -23,7 +23,6 @@ namespace } } - void ConvertStyle(LineDefProto const * pSrc, double scale, graphics::Pen::Info & dest) { double offset = 0.0; @@ -46,6 +45,45 @@ void ConvertStyle(LineDefProto const * pSrc, double scale, graphics::Pen::Info & ConvertColor(pSrc->color()), ConvertWidth(pSrc->width(), scale), v.empty() ? 0 : &v[0], v.size(), offset); + + if (pSrc->has_pathsym()) + { + PathSymProto const & ps = pSrc->pathsym(); + + dest.m_step = ps.step(); + dest.m_symbol = ps.name(); + dest.m_offset = ps.offset(); + } + + if (pSrc->has_join()) + { + switch (pSrc->join()) + { + case ROUNDJOIN: + dest.m_join = graphics::Pen::Info::ERoundJoin; + break; + case BEVELJOIN: + dest.m_join = graphics::Pen::Info::EBevelJoin; + break; + default: + break; + } + } + + if (pSrc->has_cap()) + { + switch (pSrc->cap()) + { + case ROUNDCAP: + dest.m_cap = graphics::Pen::Info::ERoundCap; + break; + case BUTTCAP: + dest.m_cap = graphics::Pen::Info::EButtCap; + break; + default: + break; + } + } } void ConvertStyle(AreaRuleProto const * pSrc, graphics::Brush::Info & dest)