All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Groups Pages
Layer.cpp
Go to the documentation of this file.
1 /* Copyright (C) 2008-2014 National Institute For Space Research (INPE) - Brazil.
2 
3  This file is part of the TerraLib - a Framework for building GIS enabled applications.
4 
5  TerraLib is free software: you can redistribute it and/or modify
6  it under the terms of the GNU Lesser General Public License as published by
7  the Free Software Foundation, either version 3 of the License,
8  or (at your option) any later version.
9 
10  TerraLib is distributed in the hope that it will be useful,
11  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  GNU Lesser General Public License for more details.
14 
15  You should have received a copy of the GNU Lesser General Public License
16  along with TerraLib. See COPYING. If not, write to
17  TerraLib Team at <terralib-team@terralib.org>.
18  */
19 
20 /*!
21  \file src/terralib/maptools/serialization/xml/Layer.cpp
22 
23  \brief Auxiliary classes and functions to read layer information from a XML document.
24 */
25 
26 // TerraLib
27 #include "../../../common/BoostUtils.h"
28 #include "../../../common/Translator.h"
29 #include "../../../color/RGBAColor.h"
30 #include "../../../dataaccess/dataset/AttributeConverterManager.h"
31 #include "../../../dataaccess/dataset/DataSetTypeConverter.h"
32 #include "../../../dataaccess/datasource/DataSourceManager.h"
33 #include "../../../dataaccess/serialization/xml/Serializer.h"
34 #include "../../../dataaccess/utils/Utils.h"
35 #include "../../../datatype/DateTimeProperty.h"
36 #include "../../../datatype/NumericProperty.h"
37 #include "../../../datatype/Property.h"
38 #include "../../../datatype/SimpleProperty.h"
39 #include "../../../datatype/StringProperty.h"
40 #include "../../../datatype/serialization/xml/Serializer.h"
41 #include "../../../geometry/Envelope.h"
42 #include "../../../geometry/GeometryProperty.h"
43 #include "../../../geometry/serialization/xml/Serializer.h"
44 #include "../../../se/CoverageStyle.h"
45 #include "../../../xml/Reader.h"
46 #include "../../../xml/Writer.h"
47 #include "../../../maptools/AbstractLayer.h"
48 #include "../../../maptools/Chart.h"
49 #include "../../../maptools/DataSetAdapterLayer.h"
50 #include "../../../maptools/DataSetLayer.h"
51 #include "../../../maptools/FolderLayer.h"
52 #include "../../../maptools/Grouping.h"
53 #include "../../../maptools/GroupingItem.h"
54 #include "../../../maptools/QueryLayer.h"
55 #include "../../../maptools/RasterLayer.h"
56 #include "../../../se/RasterSymbolizer.h"
57 #include "../../../se/serialization/xml/Style.h"
58 #include "../../../se/serialization/xml/Symbolizer.h"
59 #include "../../Exception.h"
60 #include "Layer.h"
61 
62 // STL
63 #include <cassert>
64 #include <memory>
65 
66 // Boost
67 #include <boost/algorithm/string/case_conv.hpp>
68 #include <boost/format.hpp>
69 #include <boost/lexical_cast.hpp>
70 
71 te::map::AbstractLayer* DataSetLayerReader(te::xml::Reader& reader);
72 te::map::AbstractLayer* QueryLayerReader(te::xml::Reader& reader);
73 te::map::AbstractLayer* FolderLayerReader(te::xml::Reader& reader);
74 te::map::AbstractLayer* RasterLayerReader(te::xml::Reader& reader);
75 te::map::AbstractLayer* DataSetAdapterLayerReader(te::xml::Reader& reader);
76 void DataSetLayerWriter(const te::map::AbstractLayer* layer, te::xml::Writer& writer);
77 void QueryLayerWriter(const te::map::AbstractLayer* layer, te::xml::Writer& writer);
78 void FolderLayerWriter(const te::map::AbstractLayer* layer, te::xml::Writer& writer);
79 void RasterLayerWriter(const te::map::AbstractLayer* layer, te::xml::Writer& writer);
80 void DataSetAdapterLayerWriter(const te::map::AbstractLayer* layer, te::xml::Writer& writer);
81 
82 te::map::Visibility GetVisibility(const std::string& visible)
83 {
84  return (visible == "VISIBLE") ? te::map::VISIBLE :
85  (visible == "NOT_VISIBLE") ? te::map::NOT_VISIBLE :
86  te::map::PARTIALLY_VISIBLE;
87 }
88 
89 std::string GetVisibility(const te::map::Visibility& visible)
90 {
91  return (visible == te::map::VISIBLE) ? "VISIBLE" :
92  (visible == te::map::NOT_VISIBLE) ? "NOT_VISIBLE" :
93  "PARTIALLY_VISIBLE";
94 }
95 
96 te::map::GroupingType GetGroupingType(const std::string& type)
97 {
98  if(type == "EQUAL_STEPS")
99  return te::map::EQUAL_STEPS;
100 
101  if(type == "QUANTIL")
102  return te::map::QUANTIL;
103 
104  if(type == "STD_DEVIATION")
105  return te::map::STD_DEVIATION;
106 
107  assert(type == "UNIQUE_VALUE");
108 
109  return te::map::UNIQUE_VALUE;
110 }
111 
112  std::string GetGroupingType(const te::map::GroupingType& type)
113 {
114  switch(type)
115  {
116  case te::map::EQUAL_STEPS:
117  return "EQUAL_STEPS";
118 
119  case te::map::QUANTIL:
120  return "QUANTIL";
121 
122  case te::map::STD_DEVIATION:
123  return "STD_DEVIATION";
124 
125  default:
126  {
127  assert(type == te::map::UNIQUE_VALUE);
128  return "UNIQUE_VALUE";
129  }
130  }
131 }
132 
133 te::dt::SimpleProperty* GetProperty(std::string name, int dataType, int geomType, int srid)
134 {
135  te::dt::SimpleProperty* simpleProperty = 0;
136 
137  switch(dataType)
138  {
139  case te::dt::BOOLEAN_TYPE:
140  case te::dt::CHAR_TYPE:
141  case te::dt::DOUBLE_TYPE:
142  case te::dt::FLOAT_TYPE:
143  case te::dt::INT16_TYPE:
144  case te::dt::INT32_TYPE:
145  case te::dt::INT64_TYPE:
146  case te::dt::UCHAR_TYPE:
147  case te::dt::UINT16_TYPE:
148  case te::dt::UINT32_TYPE:
149  case te::dt::UINT64_TYPE:
150  {
151  simpleProperty = new te::dt::SimpleProperty(name, dataType);
152  break;
153  }
154 
155  case te::dt::STRING_TYPE:
156  {
157  simpleProperty = new te::dt::StringProperty(name);
158  break;
159  }
160 
161  case te::dt::NUMERIC_TYPE:
162  {
163  simpleProperty = new te::dt::NumericProperty(name, 0, 0);
164  break;
165  }
166 
167  case te::dt::DATETIME_TYPE:
168  {
169  simpleProperty = new te::dt::DateTimeProperty(name);
170  break;
171  }
172 
173  case te::dt::GEOMETRY_TYPE:
174  {
175  simpleProperty = new te::gm::GeometryProperty(name, srid, (te::gm::GeomType)geomType);
176  break;
177  }
178 
179  default:
180  {
181  simpleProperty = 0;
182  return false;
183  }
184  }
185 
186  return simpleProperty;
187 }
188 
189 
190 std::string ReadLayerTitle(te::xml::Reader& reader)
191 {
192  assert(reader.getNodeType() == te::xml::START_ELEMENT);
193  assert(reader.getElementLocalName() == "Title");
194  reader.next();
195  assert(reader.getNodeType() == te::xml::VALUE);
196  std::string title = reader.getElementValue();
197  reader.next();
198  assert(reader.getNodeType() == te::xml::END_ELEMENT);
199 
200  return title;
201 }
202 
203 std::string ReadLayerVisibility(te::xml::Reader& reader)
204 {
205  assert(reader.getNodeType() == te::xml::START_ELEMENT);
206  assert(reader.getElementLocalName() == "Visible");
207  reader.next();
208  assert(reader.getNodeType() == te::xml::VALUE);
209  std::string visible = reader.getElementValue();
210  reader.next();
211  assert(reader.getNodeType() == te::xml::END_ELEMENT);
212 
213  return visible;
214 }
215 
216 te::map::GroupingItem* ReadGroupingItem(te::xml::Reader& reader)
217 {
218  assert(reader.getNodeType() == te::xml::START_ELEMENT);
219  assert(reader.getElementLocalName() == "GroupingItem");
220 
221  std::auto_ptr<te::map::GroupingItem> item(new te::map::GroupingItem);
222 
223  reader.next();
224 
225  /* Title */
226  assert(reader.getElementLocalName() == "Title");
227  reader.next();
228  assert(reader.getNodeType() == te::xml::VALUE);
229  std::string title = reader.getElementValue();
230  reader.next();
231  assert(reader.getNodeType() == te::xml::END_ELEMENT);
232 
233  item->setTitle(title);
234 
235  reader.next();
236  assert(reader.getNodeType() == te::xml::START_ELEMENT);
237 
238  if(reader.getElementLocalName() == "From")
239  {
240  /* From */
241  reader.next();
242  assert(reader.getNodeType() == te::xml::VALUE);
243  std::string fromValue = reader.getElementValue();
244  reader.next();
245  assert(reader.getNodeType() == te::xml::END_ELEMENT);
246 
247  item->setLowerLimit(fromValue);
248 
249  reader.next();
250 
251  /* To */
252  assert(reader.getNodeType() == te::xml::START_ELEMENT);
253  assert(reader.getElementLocalName() == "To");
254  reader.next();
255  assert(reader.getNodeType() == te::xml::VALUE);
256  std::string toValue = reader.getElementValue();
257  reader.next();
258  assert(reader.getNodeType() == te::xml::END_ELEMENT);
259 
260  item->setUpperLimit(toValue);
261 
262  reader.next();
263  }
264  else
265  {
266  /* Value */
267  assert(reader.getElementLocalName() == "Value");
268  reader.next();
269  assert(reader.getNodeType() == te::xml::VALUE);
270  std::string value = reader.getElementValue();
271  reader.next();
272  assert(reader.getNodeType() == te::xml::END_ELEMENT);
273 
274  item->setValue(value);
275 
276  reader.next();
277  }
278 
279  /* Symbolizers */
280  std::vector<te::se::Symbolizer*> symbs;
281  while(reader.getNodeType() == te::xml::START_ELEMENT &&
282  reader.getElementLocalName().find("Symbolizer") != std::string::npos)
283  {
284  symbs.push_back(te::se::serialize::Symbolizer::getInstance().read(reader));
285  }
286 
287  assert(reader.getNodeType() == te::xml::END_ELEMENT);
288  reader.next();
289 
290  item->setSymbolizers(symbs);
291 
292  return item.release();
293 }
294 
295 te::map::Grouping* ReadLayerGrouping(te::xml::Reader& reader)
296 {
297  if(reader.getElementLocalName() != "Grouping")
298  return 0;
299 
300  /* Property Name */
301  reader.next();
302  assert(reader.getNodeType() == te::xml::START_ELEMENT);
303  assert(reader.getElementLocalName() == "PropertyName");
304  reader.next();
305  assert(reader.getNodeType() == te::xml::VALUE);
306  std::string propertyName = reader.getElementValue();
307  reader.next();
308  assert(reader.getNodeType() == te::xml::END_ELEMENT);
309 
310  /* Property Data Type */
311  reader.next();
312  assert(reader.getNodeType() == te::xml::START_ELEMENT);
313  assert(reader.getElementLocalName() == "PropertyDataType");
314  reader.next();
315  assert(reader.getNodeType() == te::xml::VALUE);
316  int propertyType = reader.getElementValueAsInt32();
317  reader.next();
318  assert(reader.getNodeType() == te::xml::END_ELEMENT);
319 
320  /* Grouping Type */
321  reader.next();
322  assert(reader.getNodeType() == te::xml::START_ELEMENT);
323  assert(reader.getElementLocalName() == "Type");
324  reader.next();
325  assert(reader.getNodeType() == te::xml::VALUE);
326  std::string type = reader.getElementValue();
327  reader.next();
328  assert(reader.getNodeType() == te::xml::END_ELEMENT);
329 
330  /* Precision */
331  reader.next();
332  assert(reader.getNodeType() == te::xml::START_ELEMENT);
333  assert(reader.getElementLocalName() == "Precision");
334  reader.next();
335  assert(reader.getNodeType() == te::xml::VALUE);
336  std::size_t precision = static_cast<std::size_t>(reader.getElementValueAsInt32());
337  reader.next();
338  assert(reader.getNodeType() == te::xml::END_ELEMENT);
339 
340  std::auto_ptr<te::map::Grouping> g(new te::map::Grouping(propertyName, GetGroupingType(type), precision));
341  g->setPropertyType(propertyType);
342 
343  reader.next();
344  if(reader.getElementLocalName() == "StandardDeviation")
345  {
346  assert(reader.getNodeType() == te::xml::START_ELEMENT);
347  reader.next();
348  assert(reader.getNodeType() == te::xml::VALUE);
349  double stdDeviation = reader.getElementValueAsDouble();
350  reader.next();
351  assert(reader.getNodeType() == te::xml::END_ELEMENT);
352 
353  g->setStdDeviation(stdDeviation);
354 
355  reader.next();
356  }
357 
358  /* Grouping Items */
359  std::vector<te::map::GroupingItem*> items;
360  while(reader.getNodeType() == te::xml::START_ELEMENT &&
361  reader.getElementLocalName() == "GroupingItem")
362  {
363  items.push_back(ReadGroupingItem(reader));
364  }
365 
366  assert(reader.getNodeType() == te::xml::END_ELEMENT);
367  reader.next();
368 
369  g->setGroupingItems(items);
370 
371  return g.release();
372 }
373 
374 std::auto_ptr<te::map::Chart> ReadLayerChart(te::xml::Reader& reader)
375 {
376  if(reader.getElementLocalName() != "Chart")
377  return std::auto_ptr<te::map::Chart>();
378 
379  assert(reader.getNodeType() == te::xml::START_ELEMENT);
380  assert(reader.getElementLocalName() == "Chart");
381 
382  reader.next();
383 
384  assert(reader.getNodeType() == te::xml::START_ELEMENT);
385  assert(reader.getElementLocalName() == "Type");
386 
387  reader.next();
388 
389  assert(reader.getNodeType() == te::xml::VALUE);
390 
391  te::map::ChartType type = reader.getElementValue() == "PIE" ? te::map::Pie : te::map::Bar;
392 
393  reader.next();
394 
395  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Type
396 
397  reader.next();
398 
399  assert(reader.getNodeType() == te::xml::START_ELEMENT);
400  assert(reader.getElementLocalName() == "ContourColor");
401 
402  reader.next();
403 
404  assert(reader.getNodeType() == te::xml::VALUE);
405 
406  std::string hexColor = reader.getElementValue();
407 
408  te::color::RGBAColor contourColor(hexColor);
409 
410  reader.next();
411 
412  assert(reader.getNodeType() == te::xml::END_ELEMENT); // ContourColor
413 
414  reader.next();
415 
416  assert(reader.getNodeType() == te::xml::START_ELEMENT);
417  assert(reader.getElementLocalName() == "ContourWidth");
418 
419  reader.next();
420 
421  assert(reader.getNodeType() == te::xml::VALUE);
422 
423  std::size_t contourWidth = reader.getElementValueAsInt32();
424 
425  reader.next();
426 
427  assert(reader.getNodeType() == te::xml::END_ELEMENT); // ContourWidth
428 
429  reader.next();
430 
431  assert(reader.getNodeType() == te::xml::START_ELEMENT);
432  assert(reader.getElementLocalName() == "Height");
433 
434  reader.next();
435 
436  assert(reader.getNodeType() == te::xml::VALUE);
437 
438  std::size_t height = reader.getElementValueAsInt32();
439 
440  reader.next();
441 
442  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Height
443 
444  reader.next();
445 
446  std::size_t barWidth = -1;
447 
448  if(reader.getNodeType() == te::xml::START_ELEMENT &&
449  reader.getElementLocalName() == "BarWidth")
450  {
451  reader.next();
452 
453  assert(reader.getNodeType() == te::xml::VALUE);
454 
455  barWidth = reader.getElementValueAsInt32();
456 
457  reader.next();
458 
459  assert(reader.getNodeType() == te::xml::END_ELEMENT); // BarWidth
460 
461  reader.next();
462  }
463 
464  assert(reader.getNodeType() == te::xml::START_ELEMENT);
465  assert(reader.getElementLocalName() == "IsVisible");
466 
467  reader.next();
468 
469  assert(reader.getNodeType() == te::xml::VALUE);
470 
471  bool isVisible = reader.getElementValueAsBoolean();
472 
473  reader.next();
474 
475  assert(reader.getNodeType() == te::xml::END_ELEMENT); // IsVisible
476 
477  reader.next();
478 
479  double maxValue = 0;
480  if(type == te::map::Bar)
481  {
482  assert(reader.getNodeType() == te::xml::START_ELEMENT);
483  assert(reader.getElementLocalName() == "MaxValue");
484 
485  reader.next();
486 
487  assert(reader.getNodeType() == te::xml::VALUE);
488 
489  maxValue = reader.getElementValueAsDouble();
490 
491  reader.next();
492 
493  assert(reader.getNodeType() == te::xml::END_ELEMENT); // MaxValue
494 
495  reader.next();
496  }
497 
498  std::vector<std::string> properties;
499  std::vector<te::color::RGBAColor> colors;
500 
501  while(reader.getNodeType() == te::xml::START_ELEMENT &&
502  reader.getElementLocalName() == "Slice")
503  {
504  reader.next();
505 
506  assert(reader.getNodeType() == te::xml::START_ELEMENT);
507  assert(reader.getElementLocalName() == "PropertyName");
508 
509  reader.next();
510 
511  assert(reader.getNodeType() == te::xml::VALUE);
512 
513  std::string propName = reader.getElementValue();
514 
515  reader.next();
516 
517  assert(reader.getNodeType() == te::xml::END_ELEMENT); // PropertyName
518 
519  reader.next();
520 
521  assert(reader.getNodeType() == te::xml::START_ELEMENT);
522  assert(reader.getElementLocalName() == "Color");
523 
524  reader.next();
525 
526  assert(reader.getNodeType() == te::xml::VALUE);
527 
528  std::string hColor = reader.getElementValue();
529  te::color::RGBAColor color(hColor);
530 
531  reader.next();
532  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Color
533 
534  reader.next();
535  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Slice
536 
537  reader.next();
538 
539  properties.push_back(propName);
540  colors.push_back(hColor);
541  }
542 
543  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Chart
544 
545  reader.next();
546 
547  std::auto_ptr<te::map::Chart> chart(new te::map::Chart(type, properties, colors));
548  chart->setContourColor(contourColor);
549  chart->setContourWidth(contourWidth);
550  chart->setHeight(height);
551  chart->setVisibility(isVisible);
552  if(barWidth != -1)
553  chart->setBarWidth(barWidth);
554  if(type == te::map::Bar)
555  chart->setMaxValue(maxValue);
556 
557  return chart;
558 }
559 
560 void WriteLayerChart(te::map::Chart* chart, te::xml::Writer& writer)
561 {
562  writer.writeStartElement("te_map:Chart");
563 
564  te::map::ChartType type = chart->getType();
565 
566  writer.writeElement("te_map:Type", (type == te::map::Pie ? "PIE" : "BAR"));
567 
568  writer.writeElement("te_map:ContourColor", chart->getContourColor().getColor());
569 
570  writer.writeElement("te_map:ContourWidth", boost::lexical_cast<int>(chart->getContourWidth()));
571 
572  writer.writeElement("te_map:Height", boost::lexical_cast<int>(chart->getHeight()));
573 
574  if(chart->getType() == te::map::Bar)
575  writer.writeElement("te_map:BarWidth", boost::lexical_cast<int>(chart->getBarWidth()));
576 
577  writer.writeElement("te_map:IsVisible", (chart->isVisible() ? "true" : "false"));
578 
579  if(chart->getType() == te::map::Bar)
580  writer.writeElement("te_map:MaxValue", chart->getMaxValue());
581 
582  std::vector<std::string> properties = chart->getProperties();
583 
584  for(std::size_t i = 0; i < properties.size(); ++i)
585  {
586  writer.writeStartElement("te_map:Slice");
587 
588  writer.writeElement("te_map:PropertyName", properties[i]);
589 
590  writer.writeElement("te_map:Color", chart->getColor(i).getColor());
591 
592  writer.writeEndElement("te_map:Slice");
593  }
594 
595  writer.writeEndElement("te_map:Chart");
596 }
597 
598 void WriteLayerGrouping(te::map::Grouping* g, te::xml::Writer& writer)
599 {
600  writer.writeStartElement("te_map:Grouping");
601 
602  te::map::GroupingType type = g->getType();
603 
604  writer.writeElement("te_map:PropertyName", g->getPropertyName());
605  writer.writeElement("te_map:PropertyDataType", g->getPropertyType());
606  writer.writeElement("te_map:Type", GetGroupingType(type));
607  writer.writeElement("te_map:Precision", static_cast<unsigned int>(g->getPrecision()));
608 
609  if(type == te::map::STD_DEVIATION)
610  writer.writeElement("te_map:StandardDeviation", g->getStdDeviation());
611 
612  const std::vector<te::map::GroupingItem*>& items = g->getGroupingItems();
613 
614  for(std::size_t i = 0; i < items.size(); ++i)
615  {
616  te::map::GroupingItem* item = items[i];
617  assert(item);
618 
619  writer.writeStartElement("te_map:GroupingItem");
620 
621  writer.writeElement("te_map:Title", item->getTitle());
622 
623  if(type != te::map::UNIQUE_VALUE)
624  {
625  writer.writeElement("te_map:From", item->getLowerLimit());
626  writer.writeElement("te_map:To", item->getUpperLimit());
627  }
628  else
629  writer.writeElement("te_map:Value", item->getValue());
630 
631  const std::vector<te::se::Symbolizer*>& symbs = item->getSymbolizers();
632 
633  for(std::size_t j = 0; j < symbs.size(); ++j)
634  te::se::serialize::Symbolizer::getInstance().write(symbs[j], writer);
635 
636  writer.writeEndElement("te_map:GroupingItem");
637  }
638 
639  writer.writeEndElement("te_map:Grouping");
640 }
641 
642 void WriteAbstractLayer(const te::map::AbstractLayer* layer, te::xml::Writer& writer)
643 {
644  writer.writeAttribute("id", layer->getId());
645  writer.writeElement("te_map:Title", layer->getTitle());
646  writer.writeElement("te_map:Visible", GetVisibility(layer->getVisibility()));
647 
648  te::map::Grouping* g = layer->getGrouping();
649 
650  if(g != 0)
651  WriteLayerGrouping(g, writer);
652 
653  te::map::Chart* chart = layer->getChart();
654 
655  if(chart != 0)
656  WriteLayerChart(chart, writer);
657 }
658 
659 void WriteOGRAbstractLayer(const te::map::AbstractLayer* layer, te::xml::Writer& writer)
660 {
661  writer.writeAttribute("id", layer->getId());
662  writer.writeElement("te_map:Title", te::common::ConvertLatin1UTFString(layer->getTitle()));
663  writer.writeElement("te_map:Visible", GetVisibility(layer->getVisibility()));
664 
665  te::map::Grouping* g = layer->getGrouping();
666 
667  if(g != 0)
668  WriteLayerGrouping(g, writer);
669 
670  te::map::Chart* chart = layer->getChart();
671 
672  if(chart != 0)
673  WriteLayerChart(chart, writer);
674 }
675 
676 void te::map::serialize::Layer::reg(const std::string& layerType, const LayerFnctSerializeType& fncts)
677 {
678  m_fncts[layerType] = fncts;
679 }
680 
681 te::map::AbstractLayer* te::map::serialize::Layer::read(te::xml::Reader& reader) const
682 {
683  std::string layerType = boost::to_upper_copy(reader.getElementLocalName());
684 
685  LayerFnctIdxType::const_iterator it = m_fncts.find(layerType);
686 
687  if(it == m_fncts.end())
688  throw Exception((boost::format(TE_TR("Could not find a reader for the following layer type: %1%.")) % layerType).str());
689 
690  assert(it->second.second);
691 
692  return it->second.first(reader);
693 }
694 
695 void te::map::serialize::Layer::write(const te::map::AbstractLayer* alayer, te::xml::Writer& writer) const
696 {
697  assert(alayer);
698 
699  LayerFnctIdxType::const_iterator it = m_fncts.find(alayer->getType());
700 
701  if(it == m_fncts.end())
702  throw Exception((boost::format(TE_TR("Could not find a writer for the following layer type: %1%.")) % alayer->getType()).str());
703 
704  assert(it->second.second);
705 
706  return it->second.second(alayer, writer);
707 }
708 
709 te::map::serialize::Layer::~Layer()
710 {
711 }
712 
713 te::map::serialize::Layer::Layer()
714 {
715  m_fncts["DATASETLAYER"] = std::make_pair(LayerReadFnctType(&DataSetLayerReader), LayerWriteFnctType(&DataSetLayerWriter));
716  m_fncts["QUERYLAYER"] = std::make_pair(LayerReadFnctType(&QueryLayerReader), LayerWriteFnctType(&QueryLayerWriter));
717  m_fncts["FOLDERLAYER"] = std::make_pair(LayerReadFnctType(&FolderLayerReader), LayerWriteFnctType(&FolderLayerWriter));
718  m_fncts["RASTERLAYER"] = std::make_pair(LayerReadFnctType(&RasterLayerReader), LayerWriteFnctType(&RasterLayerWriter));
719  m_fncts["DATASETADAPTERLAYER"] = std::make_pair(LayerReadFnctType(&DataSetAdapterLayerReader), LayerWriteFnctType(&DataSetAdapterLayerWriter));
720 }
721 
722 te::map::AbstractLayer* DataSetLayerReader(te::xml::Reader& reader)
723 {
724  std::string id = reader.getAttr(0);
725 
726  /* Title Element */
727  reader.next();
728  std::string title = ReadLayerTitle(reader);
729 
730  /* Visible Element */
731  reader.next();
732  std::string visible = ReadLayerVisibility(reader);
733 
734  reader.next();
735 
736  /* Grouping */
737  te::map::Grouping* grouping = ReadLayerGrouping(reader);
738 
739  /* Chart */
740  std::auto_ptr<te::map::Chart> chart(ReadLayerChart(reader));
741 
742  /* DataSetName Element */
743  assert(reader.getNodeType() == te::xml::START_ELEMENT);
744  assert(reader.getElementLocalName() == "DataSetName");
745  reader.next();
746  assert(reader.getNodeType() == te::xml::VALUE);
747  std::string dataset = reader.getElementValue();
748  reader.next();
749  assert(reader.getNodeType() == te::xml::END_ELEMENT);
750 
751  /* DataSourceId Element */
752  reader.next();
753  assert(reader.getNodeType() == te::xml::START_ELEMENT);
754  assert(reader.getElementLocalName() == "DataSourceId");
755  reader.next();
756  assert(reader.getNodeType() == te::xml::VALUE);
757  std::string datasourceId = reader.getElementValue();
758  reader.next();
759  assert(reader.getNodeType() == te::xml::END_ELEMENT);
760 
761  /* SRID Element */
762  reader.next();
763  assert(reader.getNodeType() == te::xml::START_ELEMENT);
764  assert(reader.getElementLocalName() == "SRID");
765  reader.next();
766  assert(reader.getNodeType() == te::xml::VALUE);
767  int srid = reader.getElementValueAsInt32();
768  reader.next();
769  assert(reader.getNodeType() == te::xml::END_ELEMENT);
770 
771  /* Extent Element */
772  reader.next();
773  assert(reader.getNodeType() == te::xml::START_ELEMENT);
774  assert(reader.getElementLocalName() == "Extent");
775  std::auto_ptr<te::gm::Envelope> mbr(te::serialize::xml::ReadExtent(reader));
776 
777  /* RendererId Element */
778  assert(reader.getNodeType() == te::xml::START_ELEMENT);
779  assert(reader.getElementLocalName() == "RendererId");
780  reader.next();
781  assert(reader.getNodeType() == te::xml::VALUE);
782  std::string rendererId = reader.getElementValue();
783  reader.next();
784  assert(reader.getNodeType() == te::xml::END_ELEMENT);
785 
786  /* has a Style Element ? */
787  reader.next();
788 
789  std::auto_ptr<te::se::Style> style;
790 
791  if((reader.getNodeType() == te::xml::START_ELEMENT) &&
792  (reader.getElementLocalName() == "Style"))
793  {
794  reader.next();
795  assert(reader.getNodeType() == te::xml::START_ELEMENT);
796 
797  style.reset(te::se::serialize::Style::getInstance().read(reader));
798 
799  assert(reader.getNodeType() == te::xml::END_ELEMENT);
800  assert(reader.getElementLocalName() == "Style");
801 
802  reader.next();
803  }
804 
805  assert(reader.getNodeType() == te::xml::END_ELEMENT);
806  assert(reader.getElementLocalName() == "DataSetLayer");
807 
808  reader.next();
809 
810  std::auto_ptr<te::map::DataSetLayer> layer(new te::map::DataSetLayer(id, title, 0));
811  layer->setSRID(srid);
812  layer->setExtent(*mbr.get());
813  layer->setVisibility(GetVisibility(visible));
814  layer->setDataSetName(dataset);
815  layer->setDataSourceId(datasourceId);
816  layer->setRendererType(rendererId);
817  layer->setStyle(style.release());
818 
819  if(grouping)
820  layer->setGrouping(grouping);
821 
822  if(chart.get())
823  layer->setChart(chart.release());
824 
825  return layer.release();
826 }
827 
828 te::map::AbstractLayer* QueryLayerReader(te::xml::Reader& reader)
829 {
830  std::string id = reader.getAttr(0);
831 
832  /* Title Element */
833  reader.next();
834  std::string title = ReadLayerTitle(reader);
835 
836  /* Visible Element */
837  reader.next();
838  std::string visible = ReadLayerVisibility(reader);
839  reader.next();
840 
841  /* Grouping */
842  te::map::Grouping* grouping = ReadLayerGrouping(reader);
843 
844  /* Query Element */
845  assert(reader.getNodeType() == te::xml::START_ELEMENT);
846  assert(reader.getElementLocalName() == "Select");
847  te::da::Select* query = te::serialize::xml::ReadSelect(reader);
848 
849  /* DataSourceId Element */
850  assert(reader.getNodeType() == te::xml::START_ELEMENT);
851  assert(reader.getElementLocalName() == "DataSourceId");
852  reader.next();
853  assert(reader.getNodeType() == te::xml::VALUE);
854  std::string datasourceId = reader.getElementValue();
855  reader.next();
856  assert(reader.getNodeType() == te::xml::END_ELEMENT);
857 
858  /* SRID Element */
859  reader.next();
860  assert(reader.getNodeType() == te::xml::START_ELEMENT);
861  assert(reader.getElementLocalName() == "SRID");
862  reader.next();
863  assert(reader.getNodeType() == te::xml::VALUE);
864  int srid = reader.getElementValueAsInt32();
865  reader.next();
866  assert(reader.getNodeType() == te::xml::END_ELEMENT);
867 
868  /* Extent Element */
869  reader.next();
870  assert(reader.getNodeType() == te::xml::START_ELEMENT);
871  assert(reader.getElementLocalName() == "Extent");
872  std::auto_ptr<te::gm::Envelope> mbr(te::serialize::xml::ReadExtent(reader));
873 
874  /* RendererId Element */
875  assert(reader.getNodeType() == te::xml::START_ELEMENT);
876  assert(reader.getElementLocalName() == "RendererId");
877  reader.next();
878  assert(reader.getNodeType() == te::xml::VALUE);
879  std::string rendererId = reader.getElementValue();
880  reader.next();
881  assert(reader.getNodeType() == te::xml::END_ELEMENT);
882 
883  /* has a Style Element ? */
884  reader.next();
885 
886  std::auto_ptr<te::se::Style> style;
887 
888  if((reader.getNodeType() == te::xml::START_ELEMENT) &&
889  (reader.getElementLocalName() == "Style"))
890  {
891  reader.next();
892  assert(reader.getNodeType() == te::xml::START_ELEMENT);
893 
894  style.reset(te::se::serialize::Style::getInstance().read(reader));
895 
896  assert(reader.getNodeType() == te::xml::END_ELEMENT);
897  assert(reader.getElementLocalName() == "Style");
898 
899  reader.next();
900  }
901 
902  assert(reader.getNodeType() == te::xml::END_ELEMENT);
903  assert(reader.getElementLocalName() == "QueryLayer");
904 
905  reader.next();
906 
907  std::auto_ptr<te::map::QueryLayer> layer(new te::map::QueryLayer(id, title, 0));
908  layer->setSRID(srid);
909  layer->setExtent(*mbr.get());
910  layer->setVisibility(GetVisibility(visible));
911  layer->setQuery(query);
912  layer->setDataSourceId(datasourceId);
913  layer->setRendererType(rendererId);
914  layer->setStyle(style.release());
915 
916  if(grouping)
917  layer->setGrouping(grouping);
918 
919  return layer.release();
920 }
921 
922 te::map::AbstractLayer* FolderLayerReader(te::xml::Reader& reader)
923 {
924  std::string id = reader.getAttr(0);
925 
926  /* Title Element */
927  reader.next();
928  std::string title = ReadLayerTitle(reader);
929 
930  /* Visible Element */
931  reader.next();
932  std::string visible = ReadLayerVisibility(reader);
933 
934  reader.next();
935  assert(reader.getNodeType() == te::xml::START_ELEMENT);
936  assert(reader.getElementLocalName() == "LayerList");
937 
938  reader.next();
939 
940  std::auto_ptr<te::map::FolderLayer> flayer(new te::map::FolderLayer(id, title, 0));
941 
942  flayer->setVisibility(GetVisibility(visible));
943 
944  const te::map::serialize::Layer& lserial = te::map::serialize::Layer::getInstance();
945 
946  while((reader.getNodeType() != te::xml::END_ELEMENT) &&
947  (reader.getElementLocalName() != "LayerList"))
948  {
949  te::map::AbstractLayerPtr layer(lserial.read(reader));
950 
951  if(layer.get() == 0)
952  break;
953 
954  flayer->add(layer);
955  }
956 
957  reader.next();
958  assert(reader.getNodeType() == te::xml::END_ELEMENT);
959  assert(reader.getElementLocalName() == "FolderLayer");
960 
961  reader.next();
962 
963  return flayer.release();
964 }
965 
966 te::map::AbstractLayer* RasterLayerReader(te::xml::Reader& reader)
967 {
968  std::string id = reader.getAttr(0);
969 
970  /* Title Element */
971  reader.next();
972  std::string title = ReadLayerTitle(reader);
973 
974  /* Visible Element */
975  reader.next();
976  std::string visible = ReadLayerVisibility(reader);
977 
978  /* ConnectionInfo Element */
979  reader.next();
980  assert(reader.getNodeType() == te::xml::START_ELEMENT);
981  assert(reader.getElementLocalName() == "ConnectionInfo");
982 
983  std::map<std::string, std::string> conninfo;
984 
985  while(reader.next() &&
986  (reader.getNodeType() == te::xml::START_ELEMENT) &&
987  (reader.getElementLocalName() == "Parameter"))
988  {
989  // Parameter Name
990  reader.next();
991  assert(reader.getNodeType() == te::xml::START_ELEMENT);
992  assert(reader.getElementLocalName() == "Name");
993  reader.next();
994  assert(reader.getNodeType() == te::xml::VALUE);
995  std::string paramName = reader.getElementValue();
996  reader.next();
997  assert(reader.getNodeType() == te::xml::END_ELEMENT);
998 
999  // Parameter Value
1000  reader.next();
1001  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1002  assert(reader.getElementLocalName() == "Value");
1003  reader.next();
1004  assert(reader.getNodeType() == te::xml::VALUE);
1005  std::string paramValue = reader.getElementValue();
1006  reader.next();
1007  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1008 
1009  conninfo[paramName] = paramValue;
1010 
1011  reader.next();
1012  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1013  }
1014 
1015  assert(reader.getNodeType() == te::xml::END_ELEMENT); // End of ConnectionInfo Element
1016 
1017  /* SRID Element */
1018  reader.next();
1019  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1020  assert(reader.getElementLocalName() == "SRID");
1021  reader.next();
1022  assert(reader.getNodeType() == te::xml::VALUE);
1023  int srid = reader.getElementValueAsInt32();
1024  reader.next();
1025  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1026 
1027  /* Extent Element */
1028  reader.next();
1029  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1030  assert(reader.getElementLocalName() == "Extent");
1031  std::auto_ptr<te::gm::Envelope> mbr(te::serialize::xml::ReadExtent(reader));
1032 
1033  /* RendererId Element */
1034  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1035  assert(reader.getElementLocalName() == "RendererId");
1036  reader.next();
1037  assert(reader.getNodeType() == te::xml::VALUE);
1038  std::string rendererId = reader.getElementValue();
1039  reader.next();
1040  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1041 
1042  /* has a Style Element ? */
1043  reader.next();
1044 
1045  std::auto_ptr<te::se::Style> style;
1046 
1047  if((reader.getNodeType() == te::xml::START_ELEMENT) &&
1048  (reader.getElementLocalName() == "Style"))
1049  {
1050  reader.next();
1051  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1052 
1053  style.reset(te::se::serialize::Style::getInstance().read(reader));
1054 
1055  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1056  assert(reader.getElementLocalName() == "Style");
1057 
1058  reader.next();
1059  }
1060 
1061  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1062  assert(reader.getElementLocalName() == "RasterLayer");
1063 
1064  reader.next();
1065 
1066  std::auto_ptr<te::map::RasterLayer> layer(new te::map::RasterLayer(id, title, 0));
1067  layer->setSRID(srid);
1068  layer->setExtent(*mbr.get());
1069  layer->setRasterInfo(conninfo);
1070  layer->setVisibility(GetVisibility(visible));
1071  layer->setRendererType(rendererId);
1072  layer->setStyle(dynamic_cast<te::se::CoverageStyle*>(style.release()));
1073 
1074  return layer.release();
1075 }
1076 
1077 te::map::AbstractLayer* DataSetAdapterLayerReader(te::xml::Reader& reader)
1078 {
1079  std::string id = reader.getAttr(0);
1080 
1081  /* Title Element */
1082  reader.next();
1083  std::string title = ReadLayerTitle(reader);
1084 
1085  /* Visible Element */
1086  reader.next();
1087  std::string visible = ReadLayerVisibility(reader);
1088 
1089  reader.next();
1090 
1091  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1092  assert(reader.getElementLocalName() == "DataSetName");
1093 
1094  reader.next();
1095 
1096  assert(reader.getNodeType() == te::xml::VALUE);
1097 
1098  std::string dataSetName = reader.getElementValue();
1099 
1100  reader.next();
1101 
1102  assert(reader.getNodeType() == te::xml::END_ELEMENT); // DataSetName
1103 
1104  reader.next();
1105 
1106  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1107  assert(reader.getElementLocalName() == "DataSourceId");
1108 
1109  reader.next();
1110 
1111  assert(reader.getNodeType() == te::xml::VALUE);
1112 
1113  std::string dataSourceId = reader.getElementValue();
1114 
1115  reader.next();
1116 
1117  assert(reader.getNodeType() == te::xml::END_ELEMENT); // DataSourceId
1118 
1119  reader.next();
1120 
1121  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1122  assert(reader.getElementLocalName() == "RendererType");
1123 
1124  reader.next();
1125 
1126  assert(reader.getNodeType() == te::xml::VALUE);
1127 
1128  std::string rendererType = reader.getElementValue();
1129 
1130  reader.next();
1131 
1132  assert(reader.getNodeType() == te::xml::END_ELEMENT); //RendererType
1133 
1134  /* has a Style Element ? */
1135  reader.next();
1136 
1137  std::auto_ptr<te::se::Style> style;
1138 
1139  if((reader.getNodeType() == te::xml::START_ELEMENT) &&
1140  (reader.getElementLocalName() == "Style"))
1141  {
1142  reader.next();
1143  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1144 
1145  style.reset(te::se::serialize::Style::getInstance().read(reader));
1146 
1147  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1148  assert(reader.getElementLocalName() == "Style");
1149 
1150  reader.next();
1151  }
1152 
1153  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1154  assert(reader.getElementLocalName() == "Converter");
1155 
1156  reader.next();
1157 
1158  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1159  assert(reader.getElementLocalName() == "InDataSetTypeName");
1160 
1161  reader.next();
1162 
1163  std::string inDataSetName = reader.getElementValue();
1164 
1165  reader.next();
1166 
1167  assert(reader.getNodeType() == te::xml::END_ELEMENT); // InDataSetTypeName
1168 
1169  reader.next();
1170 
1171  std::vector<std::pair<std::string, std::vector<std::size_t> > > props;
1172 
1173  while(reader.getNodeType() == te::xml::START_ELEMENT &&
1174  reader.getElementLocalName() == "OutPropInfo")
1175  {
1176  reader.next();
1177 
1178  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1179  assert(reader.getElementLocalName() == "type");
1180 
1181  reader.next();
1182 
1183  assert(reader.getNodeType() == te::xml::VALUE);
1184 
1185  int type = reader.getElementValueAsInt32();
1186 
1187  reader.next();
1188 
1189  assert(reader.getNodeType() == te::xml::END_ELEMENT); // type
1190 
1191  reader.next();
1192 
1193  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1194  assert(reader.getElementLocalName() == "name");
1195 
1196  reader.next();
1197 
1198  assert(reader.getNodeType() == te::xml::VALUE);
1199 
1200  std::string name = reader.getElementValue();
1201 
1202  reader.next();
1203 
1204  assert(reader.getNodeType() == te::xml::END_ELEMENT); // name
1205 
1206  reader.next();
1207 
1208  int geomType;
1209  int srid;
1210 
1211  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1212  assert(reader.getElementLocalName() == "geomType");
1213 
1214  reader.next();
1215 
1216  assert(reader.getNodeType() == te::xml::VALUE);
1217 
1218  geomType = reader.getElementValueAsInt32();
1219 
1220  reader.next();
1221 
1222  assert(reader.getNodeType() == te::xml::END_ELEMENT); // geomType
1223 
1224  reader.next();
1225 
1226  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1227  assert(reader.getElementLocalName() == "srid");
1228 
1229  reader.next();
1230 
1231  assert(reader.getNodeType() == te::xml::VALUE);
1232 
1233  srid = reader.getElementValueAsInt32();
1234 
1235  reader.next();
1236 
1237  assert(reader.getNodeType() == te::xml::END_ELEMENT); // srid
1238 
1239  reader.next();
1240 
1241  assert(reader.getNodeType() == te::xml::END_ELEMENT); // OutPropInfo
1242 
1243  reader.next();
1244 
1245  std::pair<std::string, std::vector<std::size_t> > prop;
1246  prop.first = name;
1247  std::vector<std::size_t> typeVec;
1248  typeVec.push_back(type);
1249  typeVec.push_back(geomType);
1250  typeVec.push_back(srid);
1251  prop.second = typeVec;
1252  props.push_back(prop);
1253  }
1254 
1255  std::vector<std::vector<std::size_t> > propertyIndexes;
1256 
1257  while(reader.getNodeType() == te::xml::START_ELEMENT &&
1258  reader.getElementLocalName() == "PropertyIndex")
1259  {
1260 
1261  int outIdx;
1262  outIdx = reader.getAttrAsInt32("OutIdx");
1263 
1264  reader.next();
1265 
1266  std::vector<std::size_t> inIdxs;
1267 
1268  while(reader.getNodeType() == te::xml::START_ELEMENT &&
1269  reader.getElementLocalName() == "InIdx")
1270  {
1271  reader.next();
1272 
1273  assert(reader.getNodeType() == te::xml::VALUE);
1274 
1275  inIdxs.push_back(reader.getElementValueAsInt32());
1276 
1277  reader.next();
1278 
1279  assert(reader.getNodeType() == te::xml::END_ELEMENT); // InIdx
1280 
1281  reader.next();
1282  }
1283 
1284  assert(reader.getNodeType() == te::xml::END_ELEMENT); // InIdx
1285 
1286  propertyIndexes.push_back(inIdxs);
1287 
1288  reader.next();
1289  }
1290 
1291  std::vector<std::string> functionsNames;
1292 
1293  int teste = 0;
1294  while(reader.getNodeType() == te::xml::START_ELEMENT &&
1295  reader.getElementLocalName() == "FunctionName")
1296  {
1297  ++teste;
1298 
1299  reader.next();
1300 
1301  assert(reader.getNodeType() == te::xml::VALUE);
1302 
1303  functionsNames.push_back(reader.getElementValue());
1304 
1305  reader.next();
1306 
1307  assert(reader.getNodeType() == te::xml::END_ELEMENT); // FunctionName
1308 
1309  reader.next();
1310  }
1311 
1312  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Converter
1313 
1314  reader.next();
1315 
1316  assert(reader.getNodeType() == te::xml::END_ELEMENT); // DataSetAdapterLayer
1317 
1318  reader.next();
1319 
1320  te::map::DataSetAdapterLayer* result = new te::map::DataSetAdapterLayer(id);
1321  result->setTitle(title);
1322 
1323  result->setVisibility(GetVisibility(visible));
1324  result->setDataSetName(dataSetName);
1325  result->setDataSourceId(dataSourceId);
1326  result->setRendererType(rendererType);
1327  result->setStyle(style.release());
1328 
1329  te::da::DataSourcePtr ds = te::da::GetDataSource(dataSourceId);
1330  std::auto_ptr<te::da::DataSetType> dst = ds->getDataSetType(dataSetName);
1331 
1332  std::auto_ptr<te::da::DataSetTypeConverter> converter(new te::da::DataSetTypeConverter(dst.get()));
1333 
1334  for(std::size_t i = 0; i < propertyIndexes.size(); ++i)
1335  {
1336  converter->add(propertyIndexes[i], GetProperty(props[i].first, props[i].second[0], props[i].second[1], props[i].second[2]), functionsNames[i]);
1337  }
1338 
1339  std::vector<te::dt::Property*> convertedProps = converter->getResult()->getProperties();
1340 
1341  te::da::PrimaryKey* pkIn = dst->getPrimaryKey();
1342  if(pkIn)
1343  {
1344  te::da::PrimaryKey* pk = new te::da::PrimaryKey(converter->getResult());
1345 
1346  std::vector<te::dt::Property*> pkProps = pkIn->getProperties();
1347  for(std::size_t i = 0; i < convertedProps.size(); ++i)
1348  {
1349  for(std::size_t t = 0; t < pkProps.size(); ++t)
1350  {
1351  if(convertedProps[i]->getName() == pkProps[t]->getName())
1352  pk->add(convertedProps[i]);
1353 
1354  }
1355  }
1356  }
1357 
1358  result->setConverter(converter);
1359 
1360  te::gm::Envelope* env = new te::gm::Envelope;
1361 
1362  std::auto_ptr<te::da::DataSet> dataset = result->getData();
1363 
1364  te::gm::GeometryProperty* gp = te::da::GetFirstGeomProperty(result->getConverter()->getResult());
1365 
1366  if(gp)
1367  {
1368  while(dataset->moveNext())
1369  {
1370  te::gm::Geometry* geom = dataset->getGeometry(gp->getName()).release();
1371  assert(geom);
1372  env->Union(*geom->getMBR());
1373  }
1374  }
1375 
1376  result->setExtent(*env);
1377 
1378  return result;
1379 }
1380 
1381 void DataSetLayerWriter(const te::map::AbstractLayer* alayer, te::xml::Writer& writer)
1382 {
1383  const te::map::DataSetLayer* layer = dynamic_cast<const te::map::DataSetLayer*>(alayer);
1384 
1385  if(layer == 0)
1386  return;
1387 
1388  writer.writeStartElement("te_map:DataSetLayer");
1389 
1390  WriteAbstractLayer(layer, writer);
1391 
1392  writer.writeElement("te_map:DataSetName", layer->getDataSetName());
1393  writer.writeElement("te_map:DataSourceId", layer->getDataSourceId());
1394  writer.writeElement("te_map:SRID", layer->getSRID());
1395  te::serialize::xml::SaveExtent(layer->getExtent(), writer);
1396  writer.writeElement("te_map:RendererId", layer->getRendererType());
1397 
1398  if(layer->getStyle())
1399  {
1400  writer.writeStartElement("te_map:Style");
1401 
1402  te::se::serialize::Style::getInstance().write(layer->getStyle(), writer);
1403 
1404  writer.writeEndElement("te_map:Style");
1405  }
1406 
1407  writer.writeEndElement("te_map:DataSetLayer");
1408 }
1409 
1410 void QueryLayerWriter(const te::map::AbstractLayer* alayer, te::xml::Writer& writer)
1411 {
1412  const te::map::QueryLayer* layer = dynamic_cast<const te::map::QueryLayer*>(alayer);
1413 
1414  if(layer == 0)
1415  return;
1416 
1417  writer.writeStartElement("te_map:QueryLayer");
1418 
1419  WriteAbstractLayer(layer, writer);
1420 
1421  te::serialize::xml::Save(layer->getQuery(), writer);
1422  writer.writeElement("te_map:DataSourceId", layer->getDataSourceId());
1423  writer.writeElement("te_map:SRID", layer->getSRID());
1424  te::serialize::xml::SaveExtent(layer->getExtent(), writer);
1425  writer.writeElement("te_map:RendererId", layer->getRendererType());
1426 
1427  if(layer->getStyle())
1428  {
1429  writer.writeStartElement("te_map:Style");
1430 
1431  te::se::serialize::Style::getInstance().write(layer->getStyle(), writer);
1432 
1433  writer.writeEndElement("te_map:Style");
1434  }
1435 
1436  writer.writeEndElement("te_map:QueryLayer");
1437 }
1438 
1439 void FolderLayerWriter(const te::map::AbstractLayer* alayer, te::xml::Writer& writer)
1440 {
1441  const te::map::FolderLayer* folderLayer = static_cast<const te::map::FolderLayer*>(alayer);
1442 
1443  writer.writeStartElement("te_map:FolderLayer");
1444 
1445  writer.writeAttribute("id", folderLayer->getId());
1446  writer.writeElement("te_map:Title", folderLayer->getTitle());
1447  writer.writeElement("te_map:Visible", GetVisibility(folderLayer->getVisibility()));
1448 
1449  writer.writeStartElement("te_map:LayerList");
1450 
1451  size_t count = folderLayer->getChildrenCount();
1452 
1453  for(size_t i=0; i<count; i++)
1454  te::map::serialize::Layer::getInstance().write((const te::map::AbstractLayer*) folderLayer->getChild(i).get(), writer);
1455 
1456  writer.writeEndElement("te_map:LayerList");
1457 
1458  writer.writeEndElement("te_map:FolderLayer");
1459 }
1460 
1461 void RasterLayerWriter(const te::map::AbstractLayer* alayer, te::xml::Writer& writer)
1462 {
1463  const te::map::RasterLayer* layer = dynamic_cast<const te::map::RasterLayer*>(alayer);
1464 
1465  if(layer == 0)
1466  return;
1467 
1468  writer.writeStartElement("te_map:RasterLayer");
1469 
1470  WriteAbstractLayer(layer, writer);
1471 
1472  writer.writeStartElement("te_map:ConnectionInfo");
1473  std::map<std::string, std::string> info = layer->getRasterInfo();
1474  std::map<std::string, std::string>::iterator conIt;
1475 
1476  for(conIt=info.begin(); conIt!=info.end(); ++conIt)
1477  {
1478  writer.writeStartElement("te_map:Parameter");
1479 
1480  writer.writeStartElement("te_map:Name");
1481  writer.writeValue(conIt->first);
1482  writer.writeEndElement("te_map:Name");
1483 
1484  writer.writeStartElement("te_map:Value");
1485  writer.writeValue(conIt->second);
1486  writer.writeEndElement("te_map:Value");
1487 
1488  writer.writeEndElement("te_map:Parameter");
1489  }
1490  writer.writeEndElement("te_map:ConnectionInfo");
1491 
1492  writer.writeElement("te_map:SRID", layer->getSRID());
1493  te::serialize::xml::SaveExtent(layer->getExtent(), writer);
1494  writer.writeElement("te_map:RendererId", layer->getRendererType());
1495 
1496  if(layer->getStyle())
1497  {
1498  writer.writeStartElement("te_map:Style");
1499 
1500  te::se::serialize::Style::getInstance().write(layer->getStyle(), writer);
1501 
1502  writer.writeEndElement("te_map:Style");
1503  }
1504 
1505  writer.writeEndElement("te_map:RasterLayer");
1506 }
1507 
1508 void DataSetAdapterLayerWriter(const te::map::AbstractLayer* alayer, te::xml::Writer& writer)
1509 {
1510  const te::map::DataSetAdapterLayer* layer = dynamic_cast<const te::map::DataSetAdapterLayer*>(alayer);
1511 
1512  if(layer == 0)
1513  return;
1514 
1515  writer.writeStartElement("te_map:DataSetAdapterLayer");
1516 
1517  WriteAbstractLayer(layer, writer);
1518 
1519  writer.writeElement("te_map:DataSetName", layer->getDataSetName());
1520  writer.writeElement("te_map:DataSourceId", layer->getDataSourceId());
1521  writer.writeElement("te_map:RendererType", layer->getRendererType());
1522 
1523  if(layer->getStyle())
1524  {
1525  writer.writeStartElement("te_map:Style");
1526 
1527  te::se::serialize::Style::getInstance().write(layer->getStyle(), writer);
1528 
1529  writer.writeEndElement("te_map:Style");
1530  }
1531 
1532  te::da::DataSetTypeConverter* converter = layer->getConverter();
1533 
1534  writer.writeStartElement("te_map:Converter");
1535 
1536  writer.writeElement("te_map:InDataSetTypeName", converter->getConvertee()->getName());
1537 
1538  te::da::DataSetType* resultDt = converter->getResult();
1539 
1540  std::vector<te::dt::Property*> outProps = resultDt->getProperties();
1541 
1542  for(std::size_t i = 0; i < outProps.size(); ++i)
1543  {
1544  writer.writeStartElement("te_map:OutPropInfo");
1545 
1546  writer.writeElement("te_map:type", outProps[i]->getType());
1547  writer.writeElement("te_map:name", outProps[i]->getName());
1548 
1549  if(outProps[i]->getType() == te::dt::GEOMETRY_TYPE)
1550  {
1551  te::gm::GeometryProperty* geomProp = dynamic_cast<te::gm::GeometryProperty*>(outProps[i]);
1552 
1553  writer.writeElement("te_map:geomType", geomProp->getGeometryType());
1554  writer.writeElement("te_map:srid", geomProp->getSRID());
1555  }
1556  else
1557  {
1558  writer.writeElement("te_map:geomType", -1);
1559  writer.writeElement("te_map:srid", 0);
1560  }
1561 
1562  writer.writeEndElement("te_map:OutPropInfo");
1563 
1564  }
1565 
1566  // PropertyIndexes
1567  std::vector<std::vector<std::size_t> > propertyIndexes = converter->getConvertedPropertyIndexes();
1568 
1569  for(std::size_t i = 0; i < propertyIndexes.size(); ++i)
1570  {
1571  writer.writeStartElement("te_map:PropertyIndex");
1572 
1573  writer.writeAttribute("OutIdx", (int)i);
1574 
1575  std::vector<std::size_t> inputPropertiesIdx = propertyIndexes[i];
1576 
1577  for(std::size_t j = 0; j < inputPropertiesIdx.size(); ++j)
1578  writer.writeElement("te_map:InIdx", (int)inputPropertiesIdx[j]);
1579 
1580  writer.writeEndElement("te_map:PropertyIndex");
1581  }
1582 
1583  std::vector<te::da::AttributeConverter> converters = converter->getConverters();
1584  for(std::size_t i = 0; i < converters.size(); ++i)
1585  {
1586  std::string convName = layer->getConverter()->getConverterName(i);
1587 
1588  writer.writeElement("te_map:FunctionName", convName);
1589  }
1590 
1591  writer.writeEndElement("te_map:Converter");
1592 
1593  writer.writeEndElement("te_map:DataSetAdapterLayer");
1594 }
te::da::GetDataSource
TEDATAACCESSEXPORT DataSourcePtr GetDataSource(const std::string &datasourceId, const bool opened=true)
Search for a data source with the informed id in the DataSourceManager.
Definition: Utils.cpp:259
te::common::ConvertLatin1UTFString
TECOMMONEXPORT std::string ConvertLatin1UTFString(const std::string &data, const bool &toUtf=true)
Converts a string from latin1 to utf8 and vice-versa.
Definition: BoostUtils.cpp:169
te::map::AbstractLayer::getType
virtual const std::string & getType() const =0
It returns the layer type.
te::map::AbstractLayer::getId
virtual const std::string & getId() const
It returns the layer id.
Definition: AbstractLayer.cpp:83
te::map::ChartType
ChartType
The chart types.
Definition: Enums.h:163
te::map::Chart::getType
ChartType getType() const
Definition: Chart.cpp:76
te::map::Chart::getProperties
const std::vector< std::string > & getProperties() const
Definition: Chart.cpp:81
te::gm::GeometryProperty
Geometric property.
Definition: GeometryProperty.h:51
FolderLayerWriter
void FolderLayerWriter(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:1439
te::map::Grouping::getStdDeviation
const double getStdDeviation() const
It gets the standard deviation used in the Standard Deviation grouping.
Definition: Grouping.cpp:118
te::da::PrimaryKey::add
void add(te::dt::Property *p)
It adds a property to the list of properties of the primary key.
Definition: PrimaryKey.h:123
te::gm::GeomType
GeomType
Each enumerated type is compatible with a Well-known Binary (WKB) type code.
Definition: Enums.h:41
te::map::DataSetLayer::getDataSetName
const std::string & getDataSetName() const
Definition: DataSetLayer.cpp:194
te::xml::Reader::getElementValueAsInt32
virtual boost::int32_t getElementValueAsInt32() const
It returns the element data value in the case of VALUE node.
Definition: Reader.cpp:32
GetVisibility
te::map::Visibility GetVisibility(const std::string &visible)
Definition: Layer.cpp:82
te::map::Chart::getBarWidth
std::size_t getBarWidth() const
Definition: Chart.cpp:145
te::da::DataSetTypeConverter::getConvertedPropertyIndexes
const std::vector< std::vector< std::size_t > > & getConvertedPropertyIndexes() const
Definition: DataSetTypeConverter.cpp:257
te::common::TreeItem::getChild
const TreeItemPtr & getChild(std::size_t i) const
It returns the n-th child.
Definition: TreeItem.cpp:75
te::xml::Writer::writeStartElement
virtual void writeStartElement(const std::string &qName)
Definition: Writer.cpp:44
te::map::serialize::Layer::write
void write(const te::map::AbstractLayer *alayer, te::xml::Writer &writer) const
Definition: Layer.cpp:695
te::common::TreeItem::getChildrenCount
std::size_t getChildrenCount() const
It returns the number of children of this node.
Definition: TreeItem.cpp:183
te::dt::SimpleProperty
An atomic property like an integer or double.
Definition: SimpleProperty.h:47
te::xml::Reader
This class models a XML reader object.
Definition: Reader.h:55
te::map::AbstractLayer
This is the base class for layers.
Definition: AbstractLayer.h:76
te::map::AbstractLayer::getExtent
virtual const te::gm::Envelope & getExtent() const
It returns the Layer extent (or minimum bounding box).
Definition: AbstractLayer.cpp:215
te::map::Grouping::getPropertyType
int getPropertyType() const
It gets the property type whose values will be grouped.
Definition: Grouping.cpp:77
te::da::DataSourcePtr
boost::shared_ptr< DataSource > DataSourcePtr
Definition: DataSource.h:1435
DataSetAdapterLayerWriter
void DataSetAdapterLayerWriter(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:1508
te::map::GroupingItem::getValue
const std::string & getValue() const
It gets the value of the legend item.
Definition: GroupingItem.cpp:73
te::map::AbstractLayer::getTitle
virtual const std::string & getTitle() const
It returns the layer title.
Definition: AbstractLayer.cpp:93
DataSetLayerReader
te::map::AbstractLayer * DataSetLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:722
te::map::serialize::Layer::m_fncts
LayerFnctIdxType m_fncts
Definition: Layer.h:79
ReadGroupingItem
te::map::GroupingItem * ReadGroupingItem(te::xml::Reader &reader)
Definition: Layer.cpp:216
te::da::DataSetType
A class that models the description of a dataset.
Definition: DataSetType.h:72
te::map::Grouping::getPrecision
const size_t getPrecision() const
It gets the precision used for the property values.
Definition: Grouping.cpp:98
te::xml::Writer
This class models a XML writer object.
Definition: Writer.h:52
Layer.h
Auxiliary classes and functions to read layer information from a XML document.
te::map::Grouping::getPropertyName
std::string getPropertyName() const
It gets the property name whose values will be grouped.
Definition: Grouping.cpp:66
te::xml::Writer::writeAttribute
virtual void writeAttribute(const std::string &attName, const std::string &value)
Definition: Writer.cpp:90
te::map::DataSetAdapterLayer::getConverter
te::da::DataSetTypeConverter * getConverter() const
It returns the DataSetTypeConverter.
Definition: DataSetAdapterLayer.cpp:228
WriteOGRAbstractLayer
void WriteOGRAbstractLayer(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:659
te::map::QueryLayer
A layer resulting from a query.
Definition: QueryLayer.h:50
te::map::AbstractLayer::getVisibility
virtual Visibility getVisibility() const
It returns the layer visibility.
Definition: AbstractLayer.cpp:139
te::map::RasterLayer::getRasterInfo
std::map< std::string, std::string > getRasterInfo() const
Definition: RasterLayer.cpp:202
te::map::FolderLayer
A layer that can be used as a container for other kind of layers.
Definition: FolderLayer.h:45
TE_TR
#define TE_TR(message)
It marks a string in order to get translated.
Definition: Translator.h:345
te::map::AbstractLayer::setTitle
virtual void setTitle(const std::string &title)
It sets the layer title.
Definition: AbstractLayer.cpp:98
te::da::DataSetTypeConverter::getConverterName
std::string getConverterName(std::size_t propertyPos)
This method tells which Attribute Converter was used in the porperty position.
Definition: DataSetTypeConverter.cpp:154
te::map::DataSetAdapterLayer::setDataSourceId
void setDataSourceId(const std::string &id)
Definition: DataSetAdapterLayer.cpp:290
te::gm::Envelope::Union
void Union(const Envelope &rhs)
It updates the envelop with coordinates of another envelope.
Definition: Envelope.h:555
te::xml::Reader::getElementLocalName
virtual std::string getElementLocalName() const =0
It returns the local part of the element name in the case of an element node.
te::da::DataSetTypeConverter::getConvertee
DataSetType * getConvertee()
This method returns the pointer to the DataSetType that is handled by the converter.
Definition: DataSetTypeConverter.cpp:110
te::da::PrimaryKey::getProperties
const std::vector< te::dt::Property * > & getProperties() const
It returns the properties that take part of the primary key.
Definition: PrimaryKey.h:109
te::map::AbstractLayer::getChart
virtual te::map::Chart * getChart() const
It returns the Chart associated to the Layer.
Definition: AbstractLayer.cpp:300
te::xml::Reader::getAttrAsInt32
virtual boost::int32_t getAttrAsInt32(const std::string &name) const
It returns the attribute value in the case of an element node with valid attributes.
Definition: Reader.cpp:49
te::map::DataSetAdapterLayer::setConverter
void setConverter(std::auto_ptr< te::da::DataSetTypeConverter > converter)
It sets the converter that will be used by the layer.
Definition: DataSetAdapterLayer.cpp:233
te::da::DataSetTypeConverter
An converter for DataSetType.
Definition: DataSetTypeConverter.h:58
te::map::Chart::getMaxValue
double getMaxValue() const
Definition: Chart.cpp:160
te::da::DataSetTypeConverter::getConverters
const std::vector< AttributeConverter > & getConverters() const
Definition: DataSetTypeConverter.cpp:262
te::map::DataSetAdapterLayer::getRendererType
const std::string & getRendererType() const
Definition: DataSetAdapterLayer.cpp:295
te::map::Grouping
This class contains the parameters needed for grouping the values of a Property.
Definition: Grouping.h:59
te::dt::NumericProperty
The type for arbitrary precison numbers, like numeric(p, q).
Definition: NumericProperty.h:45
te::map::DataSetAdapterLayer
A layer with reference to a DataSetTypeConverter.
Definition: DataSetAdapterLayer.h:50
te::map::Chart::getColor
const te::color::RGBAColor & getColor(std::size_t i) const
Definition: Chart.cpp:86
te::map::DataSetAdapterLayer::getData
std::auto_ptr< te::da::DataSet > getData(te::common::TraverseType travType=te::common::FORWARDONLY, const te::common::AccessPolicy accessPolicy=te::common::RAccess) const
It gets the dataset identified by the layer name.
Definition: DataSetAdapterLayer.cpp:80
te::map::serialize::Layer::LayerFnctSerializeType
std::pair< LayerReadFnctType, LayerWriteFnctType > LayerFnctSerializeType
Definition: Layer.h:62
te::map::RasterLayer
A layer with reference to a raster.
Definition: RasterLayer.h:52
te::dt::CompositeProperty::getProperties
const std::vector< Property * > & getProperties() const
It returns the list of properties describing the CompositeProperty.
Definition: CompositeProperty.h:153
te::map::serialize::Layer::read
te::map::AbstractLayer * read(te::xml::Reader &reader) const
Definition: Layer.cpp:681
te::xml::Writer::writeValue
virtual void writeValue(const std::string &value)
Definition: Writer.cpp:120
te::map::Chart
This class represents the informations needed to build map charts.
Definition: Chart.h:51
te::gm::GeometryProperty::getSRID
int getSRID() const
It returns the spatial reference system identifier associated to this property.
Definition: GeometryProperty.h:125
te::common::Singleton< Symbolizer >::getInstance
static Symbolizer & getInstance()
It returns a reference to the singleton instance.
te::xml::Reader::getElementValueAsDouble
virtual double getElementValueAsDouble() const
It returns the element data value in the case of VALUE node.
Definition: Reader.cpp:37
te::xml::Writer::writeElement
virtual void writeElement(const std::string &qName, const std::string &value)
Definition: Writer.cpp:54
te::gm::Envelope
An Envelope defines a 2D rectangular region.
Definition: Envelope.h:51
te::map::GroupingItem
A GroupingItem contains information about a grouping item associated to a layer.
Definition: GroupingItem.h:48
te::map::DataSetLayer::getDataSourceId
const std::string & getDataSourceId() const
Definition: DataSetLayer.cpp:204
GetGroupingType
te::map::GroupingType GetGroupingType(const std::string &type)
Definition: Layer.cpp:96
te::map::AbstractLayer::getStyle
virtual te::se::Style * getStyle() const
It returns the Style associated to the layer.
Definition: AbstractLayer.cpp:278
ReadLayerVisibility
std::string ReadLayerVisibility(te::xml::Reader &reader)
Definition: Layer.cpp:203
te::map::Chart::getHeight
std::size_t getHeight() const
Definition: Chart.cpp:120
te::map::Chart::isVisible
bool isVisible() const
It gets the chart visibility.
Definition: Chart.cpp:165
te::map::DataSetAdapterLayer::getDataSourceId
const std::string & getDataSourceId() const
Definition: DataSetAdapterLayer.cpp:285
te::serialize::xml::ReadExtent
TEGEOMEXPORT std::auto_ptr< te::gm::Envelope > ReadExtent(te::xml::Reader &reader)
Definition: Serializer.cpp:34
te::gm::GeometryProperty::getGeometryType
GeomType getGeometryType() const
It returns the geometry subtype allowed for the property.
Definition: GeometryProperty.h:139
te::serialize::xml::Save
TEDATAACCESSEXPORT void Save(const std::string &fileName)
Definition: Serializer.cpp:197
te::map::AbstractLayer::setVisibility
virtual void setVisibility(Visibility v)
It sets the layer visibility.
Definition: AbstractLayer.cpp:144
te::map::serialize::Layer::LayerWriteFnctType
boost::function< void(const te::map::AbstractLayer *, te::xml::Writer &)> LayerWriteFnctType
Definition: Layer.h:61
te::map::QueryLayer::getDataSourceId
const std::string & getDataSourceId() const
Definition: QueryLayer.cpp:291
QueryLayerReader
te::map::AbstractLayer * QueryLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:828
te::map::DataSetAdapterLayer::setRendererType
void setRendererType(const std::string &t)
Definition: DataSetAdapterLayer.cpp:300
RasterLayerReader
te::map::AbstractLayer * RasterLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:966
te::map::AbstractLayer::setExtent
virtual void setExtent(const te::gm::Envelope &mbr)
It sets the Layer extent (or minimum bounding box).
Definition: AbstractLayer.cpp:220
te::map::DataSetAdapterLayer::setDataSetName
void setDataSetName(const std::string &name)
Definition: DataSetAdapterLayer.cpp:280
te::map::QueryLayer::getQuery
te::da::Select * getQuery() const
Definition: QueryLayer.cpp:279
te::dt::StringProperty
The type for string types: FIXED_STRING, VAR_STRING or STRING.
Definition: StringProperty.h:47
te::map::serialize::Layer::LayerReadFnctType
boost::function< te::map::AbstractLayer *(te::xml::Reader &)> LayerReadFnctType
Definition: Layer.h:60
te::map::DataSetAdapterLayer::getDataSetName
const std::string & getDataSetName() const
Definition: DataSetAdapterLayer.cpp:275
DataSetLayerWriter
void DataSetLayerWriter(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:1381
te::xml::Writer::writeEndElement
virtual void writeEndElement(const std::string &qName)
Definition: Writer.cpp:156
te::xml::Reader::getAttr
virtual std::string getAttr(const std::string &name) const =0
It returns the attribute value in the case of an element node with valid attributes.
te::gm::Geometry
Geometry is the root class of the geometries hierarchy, it follows OGC and ISO standards.
Definition: Geometry.h:73
te::da::Select
A Select models a query to be used when retrieving data from a DataSource.
Definition: Select.h:65
te::xml::Reader::getElementValueAsBoolean
virtual bool getElementValueAsBoolean() const
It returns the element data value in the case of VALUE node.
Definition: Reader.cpp:42
WriteLayerGrouping
void WriteLayerGrouping(te::map::Grouping *g, te::xml::Writer &writer)
Definition: Layer.cpp:598
RasterLayerWriter
void RasterLayerWriter(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:1461
te::map::Grouping::getGroupingItems
const std::vector< te::map::GroupingItem * > & getGroupingItems() const
It gets the vector of grouping items.
Definition: Grouping.cpp:128
te::map::GroupingType
GroupingType
The grouping type associated to the layer.
Definition: Enums.h:150
te::map::Chart::getContourWidth
std::size_t getContourWidth() const
Definition: Chart.cpp:110
te::map::Chart::getContourColor
const te::color::RGBAColor & getContourColor() const
Definition: Chart.cpp:100
te::map::GroupingItem::getUpperLimit
const std::string & getUpperLimit() const
It gets the upper limit value of the legend item.
Definition: GroupingItem.cpp:93
te::serialize::xml::ReadSelect
TEDATAACCESSEXPORT te::da::Select * ReadSelect(te::xml::Reader &reader)
Definition: Serializer.cpp:1918
te::map::AbstractLayer::getGrouping
virtual te::map::Grouping * getGrouping() const
It returns the Grouping associated to the Layer.
Definition: AbstractLayer.cpp:289
te::da::PrimaryKey
It describes a primary key (pk) constraint.
Definition: PrimaryKey.h:52
QueryLayerWriter
void QueryLayerWriter(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:1410
te::dt::DateTimeProperty
The type for date and time types: date, date period, date duration, time duration, time instant, time period, time instant with time zone or time period with time zone.
Definition: DateTimeProperty.h:46
te::xml::Reader::getNodeType
virtual NodeType getNodeType() const =0
It return the type of node read.
GetProperty
te::dt::SimpleProperty * GetProperty(std::string name, int dataType, int geomType, int srid)
Definition: Layer.cpp:133
te::color::RGBAColor::getColor
std::string getColor() const
It gets the color encoded using two hexadecimal digits per primary-color component, in the order Red, Green, Blue, prefixed with a hash (#) sign.
Definition: RGBAColor.h:349
te::map::AbstractLayer::setStyle
virtual void setStyle(te::se::Style *style)
It sets the Style associated to the layer.
Definition: AbstractLayer.cpp:283
te::color::RGBAColor
A helper class for 32-bit RGBA (Red-Green-Blue-Alpha channel) color.
Definition: RGBAColor.h:57
WriteAbstractLayer
void WriteAbstractLayer(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:642
te::map::Grouping::getType
const GroupingType getType() const
It gets the grouping type.
Definition: Grouping.cpp:88
te::xml::Reader::getElementValue
virtual std::string getElementValue() const =0
It returns the element data value in the case of VALUE node.
te::map::QueryLayer::getRendererType
const std::string & getRendererType() const
Definition: QueryLayer.cpp:301
FolderLayerReader
te::map::AbstractLayer * FolderLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:922
te::map::AbstractLayer::getSRID
virtual int getSRID() const
It returns the Spatial Reference System ID associated to the Layer.
Definition: AbstractLayer.cpp:225
te::map::DataSetLayer
A layer with reference to a dataset.
Definition: DataSetLayer.h:47
te::map::serialize::Layer::reg
void reg(const std::string &layerType, const LayerFnctSerializeType &fncts)
Definition: Layer.cpp:676
WriteLayerChart
void WriteLayerChart(te::map::Chart *chart, te::xml::Writer &writer)
Definition: Layer.cpp:560
DataSetAdapterLayerReader
te::map::AbstractLayer * DataSetAdapterLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:1077
te::map::Visibility
Visibility
Each layer can have three states of visibility.
Definition: Enums.h:138
te::map::GroupingItem::getTitle
std::string getTitle()
It gets the title of the legend item.
Definition: GroupingItem.cpp:103
te::da::GetFirstGeomProperty
TEDATAACCESSEXPORT te::gm::GeometryProperty * GetFirstGeomProperty(const DataSetType *dt)
Definition: Utils.cpp:508
te::map::GroupingItem::getLowerLimit
const std::string & getLowerLimit() const
It gets the lower limit value of the legend item.
Definition: GroupingItem.cpp:83
te::map::GroupingItem::getSymbolizers
const std::vector< te::se::Symbolizer * > & getSymbolizers() const
It gets the symbolizer of the legend item.
Definition: GroupingItem.cpp:133
te::map::AbstractLayerPtr
boost::intrusive_ptr< AbstractLayer > AbstractLayerPtr
Definition: AbstractLayer.h:498
te::xml::Reader::next
virtual bool next()=0
It gets the next event to be read.
te::map::RasterLayer::getRendererType
const std::string & getRendererType() const
Definition: RasterLayer.cpp:170
ReadLayerGrouping
te::map::Grouping * ReadLayerGrouping(te::xml::Reader &reader)
Definition: Layer.cpp:295
te::gm::Geometry::getMBR
const Envelope * getMBR() const
It returns the minimum bounding rectangle for the geometry in an internal representation.
Definition: Geometry.cpp:103
ReadLayerTitle
std::string ReadLayerTitle(te::xml::Reader &reader)
Definition: Layer.cpp:190
ReadLayerChart
std::auto_ptr< te::map::Chart > ReadLayerChart(te::xml::Reader &reader)
Definition: Layer.cpp:374
te::serialize::xml::SaveExtent
TEGEOMEXPORT void SaveExtent(const te::gm::Envelope &e, te::xml::Writer &writer)
Definition: Serializer.cpp:52
te::map::DataSetLayer::getRendererType
const std::string & getRendererType() const
Definition: DataSetLayer.cpp:214
te::dt::Property::getName
const std::string & getName() const
It returns the property name.
Definition: Property.h:126