All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Layer.cpp
Go to the documentation of this file.
1 /* Copyright (C) 2011-2011 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 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/Style.h"
58 #include "../se/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::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::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::serialize::Layer::reg(const std::string& layerType, const LayerFnctSerializeType& fncts)
677 {
678  m_fncts[layerType] = fncts;
679 }
680 
681 te::map::AbstractLayer* te::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(TR_SERIALIZATION("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::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(TR_SERIALIZATION("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::serialize::Layer::~Layer()
710 {
711 }
712 
713 te::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::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  te::da::DataSourcePtr dsc = te::da::GetDataSource(datasourceId);
811  if (dsc.get())
812  {
813  std::auto_ptr<te::map::DataSetLayer> layer(new te::map::DataSetLayer(id, title, 0));
814  layer->setSRID(srid);
815  layer->setExtent(*mbr.get());
816  layer->setVisibility(GetVisibility(visible));
817  layer->setDataSetName(dataset);
818  layer->setDataSourceId(datasourceId);
819  layer->setRendererType(rendererId);
820  layer->setStyle(style.release());
821 
822  if(grouping)
823  layer->setGrouping(grouping);
824 
825  if(chart.get())
826  layer->setChart(chart.release());
827 
828  return layer.release();
829  }
830  return 0;
831 }
832 
833 te::map::AbstractLayer* QueryLayerReader(te::xml::Reader& reader)
834 {
835  std::string id = reader.getAttr(0);
836 
837  /* Title Element */
838  reader.next();
839  std::string title = ReadLayerTitle(reader);
840 
841  /* Visible Element */
842  reader.next();
843  std::string visible = ReadLayerVisibility(reader);
844  reader.next();
845 
846  /* Grouping */
847  te::map::Grouping* grouping = ReadLayerGrouping(reader);
848 
849  /* Query Element */
850  assert(reader.getNodeType() == te::xml::START_ELEMENT);
851  assert(reader.getElementLocalName() == "Select");
852  te::da::Select* query = te::serialize::xml::ReadSelect(reader);
853 
854  /* DataSourceId Element */
855  assert(reader.getNodeType() == te::xml::START_ELEMENT);
856  assert(reader.getElementLocalName() == "DataSourceId");
857  reader.next();
858  assert(reader.getNodeType() == te::xml::VALUE);
859  std::string datasourceId = reader.getElementValue();
860  reader.next();
861  assert(reader.getNodeType() == te::xml::END_ELEMENT);
862 
863  /* SRID Element */
864  reader.next();
865  assert(reader.getNodeType() == te::xml::START_ELEMENT);
866  assert(reader.getElementLocalName() == "SRID");
867  reader.next();
868  assert(reader.getNodeType() == te::xml::VALUE);
869  int srid = reader.getElementValueAsInt32();
870  reader.next();
871  assert(reader.getNodeType() == te::xml::END_ELEMENT);
872 
873  /* Extent Element */
874  reader.next();
875  assert(reader.getNodeType() == te::xml::START_ELEMENT);
876  assert(reader.getElementLocalName() == "Extent");
877  std::auto_ptr<te::gm::Envelope> mbr(te::serialize::xml::ReadExtent(reader));
878 
879  /* RendererId Element */
880  assert(reader.getNodeType() == te::xml::START_ELEMENT);
881  assert(reader.getElementLocalName() == "RendererId");
882  reader.next();
883  assert(reader.getNodeType() == te::xml::VALUE);
884  std::string rendererId = reader.getElementValue();
885  reader.next();
886  assert(reader.getNodeType() == te::xml::END_ELEMENT);
887 
888  /* has a Style Element ? */
889  reader.next();
890 
891  std::auto_ptr<te::se::Style> style;
892 
893  if((reader.getNodeType() == te::xml::START_ELEMENT) &&
894  (reader.getElementLocalName() == "Style"))
895  {
896  reader.next();
897  assert(reader.getNodeType() == te::xml::START_ELEMENT);
898 
899  style.reset(te::serialize::Style::getInstance().read(reader));
900 
901  assert(reader.getNodeType() == te::xml::END_ELEMENT);
902  assert(reader.getElementLocalName() == "Style");
903 
904  reader.next();
905  }
906 
907  assert(reader.getNodeType() == te::xml::END_ELEMENT);
908  assert(reader.getElementLocalName() == "QueryLayer");
909 
910  reader.next();
911 
912  std::auto_ptr<te::map::QueryLayer> layer(new te::map::QueryLayer(id, title, 0));
913  layer->setSRID(srid);
914  layer->setExtent(*mbr.get());
915  layer->setVisibility(GetVisibility(visible));
916  layer->setQuery(query);
917  layer->setDataSourceId(datasourceId);
918  layer->setRendererType(rendererId);
919  layer->setStyle(style.release());
920 
921  if(grouping)
922  layer->setGrouping(grouping);
923 
924  return layer.release();
925 }
926 
927 te::map::AbstractLayer* FolderLayerReader(te::xml::Reader& reader)
928 {
929  std::string id = reader.getAttr(0);
930 
931  /* Title Element */
932  reader.next();
933  std::string title = ReadLayerTitle(reader);
934 
935  /* Visible Element */
936  reader.next();
937  std::string visible = ReadLayerVisibility(reader);
938 
939  reader.next();
940  assert(reader.getNodeType() == te::xml::START_ELEMENT);
941  assert(reader.getElementLocalName() == "LayerList");
942 
943  reader.next();
944 
945  std::auto_ptr<te::map::FolderLayer> flayer(new te::map::FolderLayer(id, title, 0));
946 
947  flayer->setVisibility(GetVisibility(visible));
948 
949  const te::serialize::Layer& lserial = te::serialize::Layer::getInstance();
950 
951  while((reader.getNodeType() != te::xml::END_ELEMENT) &&
952  (reader.getElementLocalName() != "LayerList"))
953  {
954  te::map::AbstractLayerPtr layer(lserial.read(reader));
955 
956  if(layer.get() == 0)
957  break;
958 
959  flayer->add(layer);
960  }
961 
962  reader.next();
963  assert(reader.getNodeType() == te::xml::END_ELEMENT);
964  assert(reader.getElementLocalName() == "FolderLayer");
965 
966  reader.next();
967 
968  return flayer.release();
969 }
970 
971 te::map::AbstractLayer* RasterLayerReader(te::xml::Reader& reader)
972 {
973  std::string id = reader.getAttr(0);
974 
975  /* Title Element */
976  reader.next();
977  std::string title = ReadLayerTitle(reader);
978 
979  /* Visible Element */
980  reader.next();
981  std::string visible = ReadLayerVisibility(reader);
982 
983  /* ConnectionInfo Element */
984  reader.next();
985  assert(reader.getNodeType() == te::xml::START_ELEMENT);
986  assert(reader.getElementLocalName() == "ConnectionInfo");
987 
988  std::map<std::string, std::string> conninfo;
989 
990  while(reader.next() &&
991  (reader.getNodeType() == te::xml::START_ELEMENT) &&
992  (reader.getElementLocalName() == "Parameter"))
993  {
994  // Parameter Name
995  reader.next();
996  assert(reader.getNodeType() == te::xml::START_ELEMENT);
997  assert(reader.getElementLocalName() == "Name");
998  reader.next();
999  assert(reader.getNodeType() == te::xml::VALUE);
1000  std::string paramName = reader.getElementValue();
1001  reader.next();
1002  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1003 
1004  // Parameter Value
1005  reader.next();
1006  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1007  assert(reader.getElementLocalName() == "Value");
1008  reader.next();
1009  assert(reader.getNodeType() == te::xml::VALUE);
1010  std::string paramValue = reader.getElementValue();
1011  reader.next();
1012  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1013 
1014  conninfo[paramName] = paramValue;
1015 
1016  reader.next();
1017  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1018  }
1019 
1020  assert(reader.getNodeType() == te::xml::END_ELEMENT); // End of ConnectionInfo Element
1021 
1022  /* SRID Element */
1023  reader.next();
1024  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1025  assert(reader.getElementLocalName() == "SRID");
1026  reader.next();
1027  assert(reader.getNodeType() == te::xml::VALUE);
1028  int srid = reader.getElementValueAsInt32();
1029  reader.next();
1030  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1031 
1032  /* Extent Element */
1033  reader.next();
1034  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1035  assert(reader.getElementLocalName() == "Extent");
1036  std::auto_ptr<te::gm::Envelope> mbr(te::serialize::xml::ReadExtent(reader));
1037 
1038  /* RendererId Element */
1039  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1040  assert(reader.getElementLocalName() == "RendererId");
1041  reader.next();
1042  assert(reader.getNodeType() == te::xml::VALUE);
1043  std::string rendererId = reader.getElementValue();
1044  reader.next();
1045  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1046 
1047  /* has a Style Element ? */
1048  reader.next();
1049 
1050  std::auto_ptr<te::se::Style> style;
1051 
1052  if((reader.getNodeType() == te::xml::START_ELEMENT) &&
1053  (reader.getElementLocalName() == "Style"))
1054  {
1055  reader.next();
1056  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1057 
1058  style.reset(te::serialize::Style::getInstance().read(reader));
1059 
1060  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1061  assert(reader.getElementLocalName() == "Style");
1062 
1063  reader.next();
1064  }
1065 
1066  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1067  assert(reader.getElementLocalName() == "RasterLayer");
1068 
1069  reader.next();
1070 
1071  std::auto_ptr<te::map::RasterLayer> layer(new te::map::RasterLayer(id, title, 0));
1072  layer->setSRID(srid);
1073  layer->setExtent(*mbr.get());
1074  layer->setRasterInfo(conninfo);
1075  layer->setVisibility(GetVisibility(visible));
1076  layer->setRendererType(rendererId);
1077  layer->setStyle(dynamic_cast<te::se::CoverageStyle*>(style.release()));
1078 
1079  return layer.release();
1080 }
1081 
1082 te::map::AbstractLayer* DataSetAdapterLayerReader(te::xml::Reader& reader)
1083 {
1084  std::string id = reader.getAttr(0);
1085 
1086  /* Title Element */
1087  reader.next();
1088  std::string title = ReadLayerTitle(reader);
1089 
1090  /* Visible Element */
1091  reader.next();
1092  std::string visible = ReadLayerVisibility(reader);
1093 
1094  reader.next();
1095 
1096  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1097  assert(reader.getElementLocalName() == "DataSetName");
1098 
1099  reader.next();
1100 
1101  assert(reader.getNodeType() == te::xml::VALUE);
1102 
1103  std::string dataSetName = reader.getElementValue();
1104 
1105  reader.next();
1106 
1107  assert(reader.getNodeType() == te::xml::END_ELEMENT); // DataSetName
1108 
1109  reader.next();
1110 
1111  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1112  assert(reader.getElementLocalName() == "DataSourceId");
1113 
1114  reader.next();
1115 
1116  assert(reader.getNodeType() == te::xml::VALUE);
1117 
1118  std::string dataSourceId = reader.getElementValue();
1119 
1120  reader.next();
1121 
1122  assert(reader.getNodeType() == te::xml::END_ELEMENT); // DataSourceId
1123 
1124  reader.next();
1125 
1126  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1127  assert(reader.getElementLocalName() == "RendererType");
1128 
1129  reader.next();
1130 
1131  assert(reader.getNodeType() == te::xml::VALUE);
1132 
1133  std::string rendererType = reader.getElementValue();
1134 
1135  reader.next();
1136 
1137  assert(reader.getNodeType() == te::xml::END_ELEMENT); //RendererType
1138 
1139  /* has a Style Element ? */
1140  reader.next();
1141 
1142  std::auto_ptr<te::se::Style> style;
1143 
1144  if((reader.getNodeType() == te::xml::START_ELEMENT) &&
1145  (reader.getElementLocalName() == "Style"))
1146  {
1147  reader.next();
1148  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1149 
1150  style.reset(te::serialize::Style::getInstance().read(reader));
1151 
1152  assert(reader.getNodeType() == te::xml::END_ELEMENT);
1153  assert(reader.getElementLocalName() == "Style");
1154 
1155  reader.next();
1156  }
1157 
1158  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1159  assert(reader.getElementLocalName() == "Converter");
1160 
1161  reader.next();
1162 
1163  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1164  assert(reader.getElementLocalName() == "InDataSetTypeName");
1165 
1166  reader.next();
1167 
1168  std::string inDataSetName = reader.getElementValue();
1169 
1170  reader.next();
1171 
1172  assert(reader.getNodeType() == te::xml::END_ELEMENT); // InDataSetTypeName
1173 
1174  reader.next();
1175 
1176  std::vector<std::pair<std::string, std::vector<std::size_t> > > props;
1177 
1178  while(reader.getNodeType() == te::xml::START_ELEMENT &&
1179  reader.getElementLocalName() == "OutPropInfo")
1180  {
1181  reader.next();
1182 
1183  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1184  assert(reader.getElementLocalName() == "type");
1185 
1186  reader.next();
1187 
1188  assert(reader.getNodeType() == te::xml::VALUE);
1189 
1190  int type = reader.getElementValueAsInt32();
1191 
1192  reader.next();
1193 
1194  assert(reader.getNodeType() == te::xml::END_ELEMENT); // type
1195 
1196  reader.next();
1197 
1198  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1199  assert(reader.getElementLocalName() == "name");
1200 
1201  reader.next();
1202 
1203  assert(reader.getNodeType() == te::xml::VALUE);
1204 
1205  std::string name = reader.getElementValue();
1206 
1207  reader.next();
1208 
1209  assert(reader.getNodeType() == te::xml::END_ELEMENT); // name
1210 
1211  reader.next();
1212 
1213  int geomType;
1214  int srid;
1215 
1216  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1217  assert(reader.getElementLocalName() == "geomType");
1218 
1219  reader.next();
1220 
1221  assert(reader.getNodeType() == te::xml::VALUE);
1222 
1223  geomType = reader.getElementValueAsInt32();
1224 
1225  reader.next();
1226 
1227  assert(reader.getNodeType() == te::xml::END_ELEMENT); // geomType
1228 
1229  reader.next();
1230 
1231  assert(reader.getNodeType() == te::xml::START_ELEMENT);
1232  assert(reader.getElementLocalName() == "srid");
1233 
1234  reader.next();
1235 
1236  assert(reader.getNodeType() == te::xml::VALUE);
1237 
1238  srid = reader.getElementValueAsInt32();
1239 
1240  reader.next();
1241 
1242  assert(reader.getNodeType() == te::xml::END_ELEMENT); // srid
1243 
1244  reader.next();
1245 
1246  assert(reader.getNodeType() == te::xml::END_ELEMENT); // OutPropInfo
1247 
1248  reader.next();
1249 
1250  std::pair<std::string, std::vector<std::size_t> > prop;
1251  prop.first = name;
1252  std::vector<std::size_t> typeVec;
1253  typeVec.push_back(type);
1254  typeVec.push_back(geomType);
1255  typeVec.push_back(srid);
1256  prop.second = typeVec;
1257  props.push_back(prop);
1258  }
1259 
1260  std::vector<std::vector<std::size_t> > propertyIndexes;
1261 
1262  while(reader.getNodeType() == te::xml::START_ELEMENT &&
1263  reader.getElementLocalName() == "PropertyIndex")
1264  {
1265 
1266  int outIdx = reader.getAttrAsInt32("OutIdx");
1267 
1268  reader.next();
1269 
1270  std::vector<std::size_t> inIdxs;
1271 
1272  while(reader.getNodeType() == te::xml::START_ELEMENT &&
1273  reader.getElementLocalName() == "InIdx")
1274  {
1275  reader.next();
1276 
1277  assert(reader.getNodeType() == te::xml::VALUE);
1278 
1279  inIdxs.push_back(reader.getElementValueAsInt32());
1280 
1281  reader.next();
1282 
1283  assert(reader.getNodeType() == te::xml::END_ELEMENT); // InIdx
1284 
1285  reader.next();
1286  }
1287 
1288  assert(reader.getNodeType() == te::xml::END_ELEMENT); // InIdx
1289 
1290  propertyIndexes.push_back(inIdxs);
1291 
1292  reader.next();
1293  }
1294 
1295  std::vector<std::string> functionsNames;
1296 
1297  int teste = 0;
1298  while(reader.getNodeType() == te::xml::START_ELEMENT &&
1299  reader.getElementLocalName() == "FunctionName")
1300  {
1301  ++teste;
1302 
1303  reader.next();
1304 
1305  assert(reader.getNodeType() == te::xml::VALUE);
1306 
1307  functionsNames.push_back(reader.getElementValue());
1308 
1309  reader.next();
1310 
1311  assert(reader.getNodeType() == te::xml::END_ELEMENT); // FunctionName
1312 
1313  reader.next();
1314  }
1315 
1316  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Converter
1317 
1318  reader.next();
1319 
1320  assert(reader.getNodeType() == te::xml::END_ELEMENT); // DataSetAdapterLayer
1321 
1322  reader.next();
1323 
1324  te::map::DataSetAdapterLayer* result = new te::map::DataSetAdapterLayer(id);
1325  result->setTitle(title);
1326 
1327  result->setVisibility(GetVisibility(visible));
1328  result->setDataSetName(dataSetName);
1329  result->setDataSourceId(dataSourceId);
1330  result->setRendererType(rendererType);
1331  result->setStyle(style.release());
1332 
1333  te::da::DataSourcePtr ds = te::da::GetDataSource(dataSourceId);
1334  std::auto_ptr<te::da::DataSetType> dst = ds->getDataSetType(dataSetName);
1335 
1336  std::auto_ptr<te::da::DataSetTypeConverter> converter(new te::da::DataSetTypeConverter(dst.get()));
1337 
1338  for(std::size_t i = 0; i < propertyIndexes.size(); ++i)
1339  {
1340  converter->add(propertyIndexes[i], GetProperty(props[i].first, props[i].second[0], props[i].second[1], props[i].second[2]), functionsNames[i]);
1341  }
1342 
1343  std::vector<te::dt::Property*> convertedProps = converter->getResult()->getProperties();
1344 
1345  te::da::PrimaryKey* pkIn = dst->getPrimaryKey();
1346  if(pkIn)
1347  {
1348  te::da::PrimaryKey* pk = new te::da::PrimaryKey(converter->getResult());
1349 
1350  std::vector<te::dt::Property*> pkProps = pkIn->getProperties();
1351  for(std::size_t i = 0; i < convertedProps.size(); ++i)
1352  {
1353  for(std::size_t t = 0; t < pkProps.size(); ++t)
1354  {
1355  if(convertedProps[i]->getName() == pkProps[t]->getName())
1356  pk->add(convertedProps[i]);
1357 
1358  }
1359  }
1360  }
1361 
1362  result->setConverter(converter);
1363 
1364  te::gm::Envelope* env = new te::gm::Envelope;
1365 
1366  std::auto_ptr<te::da::DataSet> dataset = result->getData();
1367 
1368  te::gm::GeometryProperty* gp = te::da::GetFirstGeomProperty(result->getConverter()->getResult());
1369 
1370  while(dataset->moveNext())
1371  {
1372  te::gm::Geometry* geom = dataset->getGeometry(gp->getName()).release();
1373  assert(geom);
1374  env->Union(*geom->getMBR());
1375  }
1376 
1377  result->setExtent(*env);
1378 
1379  return result;
1380 }
1381 
1382 void DataSetLayerWriter(const te::map::AbstractLayer* alayer, te::xml::Writer& writer)
1383 {
1384  const te::map::DataSetLayer* layer = dynamic_cast<const te::map::DataSetLayer*>(alayer);
1385 
1386  if(layer == 0)
1387  return;
1388 
1389  writer.writeStartElement("te_map:DataSetLayer");
1390 
1391  bool ogrType = te::da::GetDataSource(layer->getDataSourceId())->getType() == "OGR";
1392 
1393  if(ogrType)
1394  WriteOGRAbstractLayer(layer, writer);
1395  else
1396  WriteAbstractLayer(layer, writer);
1397 
1398  writer.writeElement("te_map:DataSetName", (ogrType) ? te::common::ConvertLatin1UTFString(layer->getDataSetName()) : layer->getDataSetName());
1399  writer.writeElement("te_map:DataSourceId", layer->getDataSourceId());
1400  writer.writeElement("te_map:SRID", layer->getSRID());
1401  te::serialize::xml::SaveExtent(layer->getExtent(), writer);
1402  writer.writeElement("te_map:RendererId", layer->getRendererType());
1403 
1404  if(layer->getStyle())
1405  {
1406  writer.writeStartElement("te_map:Style");
1407 
1408  te::serialize::Style::getInstance().write(layer->getStyle(), writer);
1409 
1410  writer.writeEndElement("te_map:Style");
1411  }
1412 
1413  writer.writeEndElement("te_map:DataSetLayer");
1414 }
1415 
1416 void QueryLayerWriter(const te::map::AbstractLayer* alayer, te::xml::Writer& writer)
1417 {
1418  const te::map::QueryLayer* layer = dynamic_cast<const te::map::QueryLayer*>(alayer);
1419 
1420  if(layer == 0)
1421  return;
1422 
1423  writer.writeStartElement("te_map:QueryLayer");
1424 
1425  WriteAbstractLayer(layer, writer);
1426 
1427  te::serialize::xml::Save(layer->getQuery(), writer);
1428  writer.writeElement("te_map:DataSourceId", layer->getDataSourceId());
1429  writer.writeElement("te_map:SRID", layer->getSRID());
1430  te::serialize::xml::SaveExtent(layer->getExtent(), writer);
1431  writer.writeElement("te_map:RendererId", layer->getRendererType());
1432 
1433  if(layer->getStyle())
1434  {
1435  writer.writeStartElement("te_map:Style");
1436 
1437  te::serialize::Style::getInstance().write(layer->getStyle(), writer);
1438 
1439  writer.writeEndElement("te_map:Style");
1440  }
1441 
1442  writer.writeEndElement("te_map:QueryLayer");
1443 }
1444 
1445 void FolderLayerWriter(const te::map::AbstractLayer* alayer, te::xml::Writer& writer)
1446 {
1447  const te::map::FolderLayer* folderLayer = static_cast<const te::map::FolderLayer*>(alayer);
1448 
1449  writer.writeStartElement("te_map:FolderLayer");
1450 
1451  writer.writeAttribute("id", folderLayer->getId());
1452  writer.writeElement("te_map:Title", folderLayer->getTitle());
1453  writer.writeElement("te_map:Visible", GetVisibility(folderLayer->getVisibility()));
1454 
1455  writer.writeStartElement("te_map:LayerList");
1456 
1457  size_t count = folderLayer->getChildrenCount();
1458 
1459  for(size_t i=0; i<count; i++)
1460  te::serialize::Layer::getInstance().write((const te::map::AbstractLayer*) folderLayer->getChild(i).get(), writer);
1461 
1462  writer.writeEndElement("te_map:LayerList");
1463 
1464  writer.writeEndElement("te_map:FolderLayer");
1465 }
1466 
1467 void RasterLayerWriter(const te::map::AbstractLayer* alayer, te::xml::Writer& writer)
1468 {
1469  const te::map::RasterLayer* layer = dynamic_cast<const te::map::RasterLayer*>(alayer);
1470 
1471  if(layer == 0)
1472  return;
1473 
1474  writer.writeStartElement("te_map:RasterLayer");
1475 
1476  WriteAbstractLayer(layer, writer);
1477 
1478  writer.writeStartElement("te_map:ConnectionInfo");
1479  std::map<std::string, std::string> info = layer->getRasterInfo();
1480  std::map<std::string, std::string>::iterator conIt;
1481 
1482  for(conIt=info.begin(); conIt!=info.end(); ++conIt)
1483  {
1484  writer.writeStartElement("te_map:Parameter");
1485 
1486  writer.writeStartElement("te_map:Name");
1487  writer.writeValue(conIt->first);
1488  writer.writeEndElement("te_map:Name");
1489 
1490  writer.writeStartElement("te_map:Value");
1491  writer.writeValue(conIt->second);
1492  writer.writeEndElement("te_map:Value");
1493 
1494  writer.writeEndElement("te_map:Parameter");
1495  }
1496  writer.writeEndElement("te_map:ConnectionInfo");
1497 
1498  writer.writeElement("te_map:SRID", layer->getSRID());
1499  te::serialize::xml::SaveExtent(layer->getExtent(), writer);
1500  writer.writeElement("te_map:RendererId", layer->getRendererType());
1501 
1502  if(layer->getStyle())
1503  {
1504  writer.writeStartElement("te_map:Style");
1505 
1506  te::serialize::Style::getInstance().write(layer->getStyle(), writer);
1507 
1508  writer.writeEndElement("te_map:Style");
1509  }
1510 
1511  writer.writeEndElement("te_map:RasterLayer");
1512 }
1513 
1514 void DataSetAdapterLayerWriter(const te::map::AbstractLayer* alayer, te::xml::Writer& writer)
1515 {
1516  const te::map::DataSetAdapterLayer* layer = dynamic_cast<const te::map::DataSetAdapterLayer*>(alayer);
1517 
1518  if(layer == 0)
1519  return;
1520 
1521  writer.writeStartElement("te_map:DataSetAdapterLayer");
1522 
1523  WriteAbstractLayer(layer, writer);
1524 
1525  writer.writeElement("te_map:DataSetName", layer->getDataSetName());
1526  writer.writeElement("te_map:DataSourceId", layer->getDataSourceId());
1527  writer.writeElement("te_map:RendererType", layer->getRendererType());
1528 
1529  if(layer->getStyle())
1530  {
1531  writer.writeStartElement("te_map:Style");
1532 
1533  te::serialize::Style::getInstance().write(layer->getStyle(), writer);
1534 
1535  writer.writeEndElement("te_map:Style");
1536  }
1537 
1538  te::da::DataSetTypeConverter* converter = layer->getConverter();
1539 
1540  writer.writeStartElement("te_map:Converter");
1541 
1542  writer.writeElement("te_map:InDataSetTypeName", converter->getConvertee()->getName());
1543 
1544  te::da::DataSetType* resultDt = converter->getResult();
1545 
1546  std::vector<te::dt::Property*> outProps = resultDt->getProperties();
1547 
1548  for(std::size_t i = 0; i < outProps.size(); ++i)
1549  {
1550  writer.writeStartElement("te_map:OutPropInfo");
1551 
1552  writer.writeElement("te_map:type", outProps[i]->getType());
1553  writer.writeElement("te_map:name", outProps[i]->getName());
1554 
1555  if(outProps[i]->getType() == te::dt::GEOMETRY_TYPE)
1556  {
1557  te::gm::GeometryProperty* geomProp = dynamic_cast<te::gm::GeometryProperty*>(outProps[i]);
1558 
1559  writer.writeElement("te_map:geomType", geomProp->getGeometryType());
1560  writer.writeElement("te_map:srid", geomProp->getSRID());
1561  }
1562  else
1563  {
1564  writer.writeElement("te_map:geomType", -1);
1565  writer.writeElement("te_map:srid", 0);
1566  }
1567 
1568  writer.writeEndElement("te_map:OutPropInfo");
1569 
1570  }
1571 
1572  // PropertyIndexes
1573  std::vector<std::vector<std::size_t> > propertyIndexes = converter->getConvertedPropertyIndexes();
1574 
1575  for(std::size_t i = 0; i < propertyIndexes.size(); ++i)
1576  {
1577  writer.writeStartElement("te_map:PropertyIndex");
1578 
1579  writer.writeAttribute("OutIdx", (int)i);
1580 
1581  std::vector<std::size_t> inputPropertiesIdx = propertyIndexes[i];
1582 
1583  for(std::size_t j = 0; j < inputPropertiesIdx.size(); ++j)
1584  writer.writeElement("te_map:InIdx", (int)inputPropertiesIdx[j]);
1585 
1586  writer.writeEndElement("te_map:PropertyIndex");
1587  }
1588 
1589  std::vector<te::da::AttributeConverter> converters = converter->getConverters();
1590  for(std::size_t i = 0; i < converters.size(); ++i)
1591  {
1592  std::string convName = layer->getConverter()->getConverterName(i);
1593 
1594  writer.writeElement("te_map:FunctionName", convName);
1595  }
1596 
1597  writer.writeEndElement("te_map:Converter");
1598 
1599  writer.writeEndElement("te_map:DataSetAdapterLayer");
1600 }
te::map::QueryLayer::getDataSourceId
const std::string & getDataSourceId() const
Definition: QueryLayer.cpp:281
te::map::GroupingType
GroupingType
The grouping type associated to the layer.
Definition: Enums.h:150
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::DataSetLayer
A layer with reference to a dataset.
Definition: DataSetLayer.h:47
te::map::DataSetLayer::getDataSetName
const std::string & getDataSetName() const
Definition: DataSetLayer.cpp:193
te::map::AbstractLayer::getChart
virtual te::map::Chart * getChart() const
It returns the Chart associated to the Layer.
Definition: AbstractLayer.cpp:300
te::map::DataSetAdapterLayer::setDataSetName
void setDataSetName(const std::string &name)
Definition: DataSetAdapterLayer.cpp:285
te::map::Grouping
This class contains the parameters needed for grouping the values of a Property.
Definition: Grouping.h:59
te::xml::Reader::getElementValueAsBoolean
virtual bool getElementValueAsBoolean() const
It returns the element data value in the case of VALUE node.
Definition: Reader.cpp:42
DataSetAdapterLayerReader
te::map::AbstractLayer * DataSetAdapterLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:1082
te::dt::SimpleProperty
An atomic property like an integer or double.
Definition: SimpleProperty.h:47
te::map::Chart::getContourColor
const te::color::RGBAColor & getContourColor() const
Definition: Chart.cpp:98
te::serialize::xml::ReadSelect
TEDATAACCESSEXPORT te::da::Select * ReadSelect(te::xml::Reader &reader)
Definition: Serializer.cpp:1918
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::DataSetAdapterLayer::getDataSetName
const std::string & getDataSetName() const
Definition: DataSetAdapterLayer.cpp:280
te::map::Chart::getContourWidth
std::size_t getContourWidth() const
Definition: Chart.cpp:108
te::map::DataSetAdapterLayer::getDataSourceId
const std::string & getDataSourceId() const
Definition: DataSetAdapterLayer.cpp:290
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:258
te::map::Chart::getType
ChartType getType() const
Definition: Chart.cpp:74
te::da::DataSetTypeConverter
An converter for DataSetType.
Definition: DataSetTypeConverter.h:58
te::serialize::xml::Save
TEDATAACCESSEXPORT void Save(const std::string &fileName)
Definition: Serializer.cpp:191
te::map::AbstractLayer::getTitle
virtual const std::string & getTitle() const
It returns the layer title.
Definition: AbstractLayer.cpp:93
te::da::GetFirstGeomProperty
TEDATAACCESSEXPORT te::gm::GeometryProperty * GetFirstGeomProperty(const DataSetType *dt)
Definition: Utils.cpp:504
te::map::Grouping::getStdDeviation
const double getStdDeviation() const
It gets the standard deviation used in the Standard Deviation grouping.
Definition: Grouping.cpp:99
te::map::AbstractLayer
This is the base class for layers.
Definition: AbstractLayer.h:76
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::da::Select
A Select models a query to be used when retrieving data from a DataSource.
Definition: Select.h:65
te::gm::GeometryProperty::getSRID
int getSRID() const
It returns the spatial reference system identifier associated to this property.
Definition: GeometryProperty.h:125
te::serialize::Layer::read
te::map::AbstractLayer * read(te::xml::Reader &reader) const
Definition: Layer.cpp:681
te::dt::StringProperty
The type for string types: FIXED_STRING, VAR_STRING or STRING.
Definition: StringProperty.h:46
te::xml::Reader
This class models a XML reader object.
Definition: Reader.h:55
te::map::RasterLayer::getRasterInfo
std::map< std::string, std::string > getRasterInfo() const
Definition: RasterLayer.cpp:202
te::map::Chart::isVisible
bool isVisible() const
It gets the chart visibility.
Definition: Chart.cpp:163
ReadLayerTitle
std::string ReadLayerTitle(te::xml::Reader &reader)
Definition: Layer.cpp:190
te::serialize::Style::write
void write(const te::se::Style *style, te::xml::Writer &writer) const
Definition: Style.cpp:69
te::da::PrimaryKey
It describes a primary key (pk) constraint.
Definition: PrimaryKey.h:52
GetGroupingType
te::map::GroupingType GetGroupingType(const std::string &type)
Definition: Layer.cpp:96
te::xml::Reader::next
virtual bool next()=0
It gets the next event to be read.
te::dt::Property::getName
const std::string & getName() const
It returns the property name.
Definition: Property.h:126
TR_SERIALIZATION
#define TR_SERIALIZATION(message)
It marks a string in order to get translated. This is a special mark used in the XML module of TerraL...
Definition: Config.h:58
te::map::FolderLayer
A layer that can be used as a container for other kind of layers.
Definition: FolderLayer.h:45
te::map::Visibility
Visibility
Each layer can have three states of visibility.
Definition: Enums.h:138
te::map::DataSetLayer::getDataSourceId
const std::string & getDataSourceId() const
Definition: DataSetLayer.cpp:203
te::map::GroupingItem::getValue
const std::string & getValue() const
It gets the value of the legend item.
Definition: GroupingItem.cpp:73
te::map::AbstractLayer::getGrouping
virtual te::map::Grouping * getGrouping() const
It returns the Grouping associated to the Layer.
Definition: AbstractLayer.cpp:289
te::map::Grouping::getPropertyType
int getPropertyType() const
It gets the property type whose values will be grouped.
Definition: Grouping.cpp:58
te::da::DataSetTypeConverter::getConverters
const std::vector< AttributeConverter > & getConverters() const
Definition: DataSetTypeConverter.cpp:262
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::RasterLayer::getRendererType
const std::string & getRendererType() const
Definition: RasterLayer.cpp:170
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::map::QueryLayer::getRendererType
const std::string & getRendererType() const
Definition: QueryLayer.cpp:291
te::map::Chart::getProperties
const std::vector< std::string > & getProperties() const
Definition: Chart.cpp:79
te::serialize::Layer::LayerReadFnctType
boost::function< te::map::AbstractLayer *(te::xml::Reader &)> LayerReadFnctType
Definition: Layer.h:58
RasterLayerWriter
void RasterLayerWriter(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:1467
ReadGroupingItem
te::map::GroupingItem * ReadGroupingItem(te::xml::Reader &reader)
Definition: Layer.cpp:216
te::xml::Writer::writeStartElement
virtual void writeStartElement(const std::string &qName)
Definition: Writer.cpp:44
te::xml::Writer::writeAttribute
virtual void writeAttribute(const std::string &attName, const std::string &value)
Definition: Writer.cpp:90
te::map::AbstractLayer::setTitle
virtual void setTitle(const std::string &title)
It sets the layer title.
Definition: AbstractLayer.cpp:98
te::gm::GeometryProperty::getGeometryType
GeomType getGeometryType() const
It returns the geometry subtype allowed for the property.
Definition: GeometryProperty.h:139
QueryLayerReader
te::map::AbstractLayer * QueryLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:833
DataSetAdapterLayerWriter
void DataSetAdapterLayerWriter(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:1514
te::xml::Reader::getElementValue
virtual std::string getElementValue() const =0
It returns the element data value in the case of VALUE node.
te::xml::Writer::writeEndElement
virtual void writeEndElement(const std::string &qName)
Definition: Writer.cpp:156
te::map::ChartType
ChartType
The chart types.
Definition: Enums.h:163
QueryLayerWriter
void QueryLayerWriter(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:1416
te::common::TreeItem::getChildrenCount
std::size_t getChildrenCount() const
It returns the number of children of this node.
Definition: TreeItem.cpp:183
te::serialize::xml::ReadExtent
TEGEOMEXPORT std::auto_ptr< te::gm::Envelope > ReadExtent(te::xml::Reader &reader)
Definition: Serializer.cpp:34
te::gm::Geometry
Geometry is the root class of the geometries hierarchy, it follows OGC and ISO standards.
Definition: Geometry.h:73
WriteLayerChart
void WriteLayerChart(te::map::Chart *chart, te::xml::Writer &writer)
Definition: Layer.cpp:560
te::map::Grouping::getPropertyName
std::string getPropertyName() const
It gets the property name whose values will be grouped.
Definition: Grouping.cpp:47
te::color::RGBAColor
A helper class for 32-bit RGBA (Red-Green-Blue-Alpha channel) color.
Definition: RGBAColor.h:57
ReadLayerGrouping
te::map::Grouping * ReadLayerGrouping(te::xml::Reader &reader)
Definition: Layer.cpp:295
te::serialize::Layer::LayerFnctSerializeType
std::pair< LayerReadFnctType, LayerWriteFnctType > LayerFnctSerializeType
Definition: Layer.h:60
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
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::DataSetLayer::getRendererType
const std::string & getRendererType() const
Definition: DataSetLayer.cpp:213
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::gm::GeomType
GeomType
Each enumerated type is compatible with a Well-known Binary (WKB) type code.
Definition: Enums.h:41
DataSetLayerReader
te::map::AbstractLayer * DataSetLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:722
te::da::DataSourcePtr
boost::shared_ptr< DataSource > DataSourcePtr
Definition: DataSource.h:1395
te::map::QueryLayer
A layer resulting from a query.
Definition: QueryLayer.h:50
te::map::AbstractLayer::getStyle
virtual te::se::Style * getStyle() const
It returns the Style associated to the layer.
Definition: AbstractLayer.cpp:278
te::map::AbstractLayer::getType
virtual const std::string & getType() const =0
It returns the layer type.
GetProperty
te::dt::Property * GetProperty(const QString &propertyType)
Definition: AddColumnDialog.cpp:26
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::common::TreeItem::getChild
const TreeItemPtr & getChild(std::size_t i) const
It returns the n-th child.
Definition: TreeItem.cpp:75
RasterLayerReader
te::map::AbstractLayer * RasterLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:971
te::map::Grouping::getPrecision
const size_t getPrecision() const
It gets the precision used for the property values.
Definition: Grouping.cpp:79
ReadLayerVisibility
std::string ReadLayerVisibility(te::xml::Reader &reader)
Definition: Layer.cpp:203
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::Chart::getColor
const te::color::RGBAColor & getColor(std::size_t i) const
Definition: Chart.cpp:84
FolderLayerWriter
void FolderLayerWriter(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:1445
te::xml::Writer::writeElement
virtual void writeElement(const std::string &qName, const std::string &value)
Definition: Writer.cpp:54
WriteLayerGrouping
void WriteLayerGrouping(te::map::Grouping *g, te::xml::Writer &writer)
Definition: Layer.cpp:598
te::xml::Writer::writeValue
virtual void writeValue(const std::string &value)
Definition: Writer.cpp:120
te::map::AbstractLayer::setVisibility
virtual void setVisibility(Visibility v)
It sets the layer visibility.
Definition: AbstractLayer.cpp:144
te::da::DataSetType
A class that models the description of a dataset.
Definition: DataSetType.h:72
te::map::DataSetAdapterLayer::setDataSourceId
void setDataSourceId(const std::string &id)
Definition: DataSetAdapterLayer.cpp:295
te::map::GroupingItem::getSymbolizers
const std::vector< te::se::Symbolizer * > & getSymbolizers() const
It gets the symbolizer of the legend item.
Definition: GroupingItem.cpp:133
WriteAbstractLayer
void WriteAbstractLayer(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:642
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
ReadLayerChart
std::auto_ptr< te::map::Chart > ReadLayerChart(te::xml::Reader &reader)
Definition: Layer.cpp:374
te::serialize::Layer::write
void write(const te::map::AbstractLayer *alayer, te::xml::Writer &writer) const
Definition: Layer.cpp:695
te::map::DataSetAdapterLayer::setRendererType
void setRendererType(const std::string &t)
Definition: DataSetAdapterLayer.cpp:305
te::map::Chart
This class represents the informations needed to build map charts.
Definition: Chart.h:51
GetVisibility
te::map::Visibility GetVisibility(const std::string &visible)
Definition: Layer.cpp:82
te::map::DataSetAdapterLayer
A layer with reference to a DataSetTypeConverter.
Definition: DataSetAdapterLayer.h:50
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
te::dt::NumericProperty
The type for arbitrary precison numbers, like numeric(p, q).
Definition: NumericProperty.h:45
te::serialize::Layer::m_fncts
LayerFnctIdxType m_fncts
Definition: Layer.h:77
te::map::AbstractLayerPtr
boost::intrusive_ptr< AbstractLayer > AbstractLayerPtr
Definition: AbstractLayer.h:483
te::map::RasterLayer
A layer with reference to a raster.
Definition: RasterLayer.h:52
te::map::GroupingItem::getTitle
std::string getTitle()
It gets the title of the legend item.
Definition: GroupingItem.cpp:103
te::map::AbstractLayer::getVisibility
virtual Visibility getVisibility() const
It returns the layer visibility.
Definition: AbstractLayer.cpp:139
FolderLayerReader
te::map::AbstractLayer * FolderLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:927
te::common::Singleton< Symbolizer >::getInstance
static Symbolizer & getInstance()
It returns a reference to the singleton instance.
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::xml::Reader::getNodeType
virtual NodeType getNodeType() const =0
It return the type of node read.
te::serialize::xml::SaveExtent
TEGEOMEXPORT void SaveExtent(const te::gm::Envelope &e, te::xml::Writer &writer)
Definition: Serializer.cpp:52
te::gm::Envelope
An Envelope defines a 2D rectangular region.
Definition: Envelope.h:51
te::map::DataSetAdapterLayer::getConverter
te::da::DataSetTypeConverter * getConverter() const
It returns the DataSetTypeConverter.
Definition: DataSetAdapterLayer.cpp:233
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::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::map::Chart::getHeight
std::size_t getHeight() const
Definition: Chart.cpp:118
te::map::Chart::getMaxValue
double getMaxValue() const
Definition: Chart.cpp:158
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::QueryLayer::getQuery
te::da::Select * getQuery() const
Definition: QueryLayer.cpp:269
te::gm::GeometryProperty
Geometric property.
Definition: GeometryProperty.h:51
WriteOGRAbstractLayer
void WriteOGRAbstractLayer(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:659
te::map::GroupingItem::getUpperLimit
const std::string & getUpperLimit() const
It gets the upper limit value of the legend item.
Definition: GroupingItem.cpp:93
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::da::DataSetTypeConverter::getConvertedPropertyIndexes
const std::vector< std::vector< std::size_t > > & getConvertedPropertyIndexes() const
Definition: DataSetTypeConverter.cpp:257
te::map::Grouping::getGroupingItems
const std::vector< te::map::GroupingItem * > & getGroupingItems() const
It gets the vector of grouping items.
Definition: Grouping.cpp:109
te::map::AbstractLayer::getId
virtual const std::string & getId() const
It returns the layer id.
Definition: AbstractLayer.cpp:83
te::map::DataSetAdapterLayer::getRendererType
const std::string & getRendererType() const
Definition: DataSetAdapterLayer.cpp:300
te::map::Chart::getBarWidth
std::size_t getBarWidth() const
Definition: Chart.cpp:143
te::gm::Envelope::Union
void Union(const Envelope &rhs)
It updates the envelop with coordinates of another envelope.
Definition: Envelope.h:555
te::serialize::Layer::LayerWriteFnctType
boost::function< void(const te::map::AbstractLayer *, te::xml::Writer &)> LayerWriteFnctType
Definition: Layer.h:59
te::map::AbstractLayer::setStyle
virtual void setStyle(te::se::Style *style)
It sets the Style associated to the layer.
Definition: AbstractLayer.cpp:283
DataSetLayerWriter
void DataSetLayerWriter(const te::map::AbstractLayer *layer, te::xml::Writer &writer)
Definition: Layer.cpp:1382
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::serialize::Layer::reg
void reg(const std::string &layerType, const LayerFnctSerializeType &fncts)
Definition: Layer.cpp:676
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::xml::Writer
This class models a XML writer object.
Definition: Writer.h:52
te::map::Grouping::getType
const GroupingType getType() const
It gets the grouping type.
Definition: Grouping.cpp:69
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:238
te::map::GroupingItem
A GroupingItem contains information about a grouping item associated to a layer.
Definition: GroupingItem.h:48