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 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/AbstractWriter.h"
46 #include "../../../xml/Reader.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 #include "Utils.h"
62 
63 // STL
64 #include <cassert>
65 #include <memory>
66 
67 // Boost
68 #include <boost/algorithm/string/case_conv.hpp>
69 #include <boost/format.hpp>
70 #include <boost/lexical_cast.hpp>
71 
72 te::map::AbstractLayer* DataSetLayerReader(te::xml::Reader& reader);
73 te::map::AbstractLayer* QueryLayerReader(te::xml::Reader& reader);
74 te::map::AbstractLayer* FolderLayerReader(te::xml::Reader& reader);
75 te::map::AbstractLayer* RasterLayerReader(te::xml::Reader& reader);
76 te::map::AbstractLayer* DataSetAdapterLayerReader(te::xml::Reader& reader);
77 void DataSetLayerWriter(const te::map::AbstractLayer* layer, te::xml::AbstractWriter& writer);
78 void QueryLayerWriter(const te::map::AbstractLayer* layer, te::xml::AbstractWriter& writer);
79 void FolderLayerWriter(const te::map::AbstractLayer* layer, te::xml::AbstractWriter& writer);
80 void RasterLayerWriter(const te::map::AbstractLayer* layer, te::xml::AbstractWriter& writer);
81 void DataSetAdapterLayerWriter(const te::map::AbstractLayer* layer, te::xml::AbstractWriter& writer);
82 
83 te::dt::SimpleProperty* GetProperty(std::string name, int dataType, int geomType, int srid)
84 {
85  te::dt::SimpleProperty* simpleProperty = 0;
86 
87  switch(dataType)
88  {
89  case te::dt::BOOLEAN_TYPE:
90  case te::dt::CHAR_TYPE:
91  case te::dt::DOUBLE_TYPE:
92  case te::dt::FLOAT_TYPE:
93  case te::dt::INT16_TYPE:
94  case te::dt::INT32_TYPE:
95  case te::dt::INT64_TYPE:
96  case te::dt::UCHAR_TYPE:
97  case te::dt::UINT16_TYPE:
98  case te::dt::UINT32_TYPE:
99  case te::dt::UINT64_TYPE:
100  {
101  simpleProperty = new te::dt::SimpleProperty(name, dataType);
102  break;
103  }
104 
105  case te::dt::STRING_TYPE:
106  {
107  simpleProperty = new te::dt::StringProperty(name);
108  break;
109  }
110 
111  case te::dt::NUMERIC_TYPE:
112  {
113  simpleProperty = new te::dt::NumericProperty(name, 0, 0);
114  break;
115  }
116 
117  case te::dt::DATETIME_TYPE:
118  {
119  simpleProperty = new te::dt::DateTimeProperty(name);
120  break;
121  }
122 
123  case te::dt::GEOMETRY_TYPE:
124  {
125  simpleProperty = new te::gm::GeometryProperty(name, srid, (te::gm::GeomType)geomType);
126  break;
127  }
128 
129  default:
130  {
131  simpleProperty = 0;
132  return false;
133  }
134  }
135 
136  return simpleProperty;
137 }
138 
139 void te::map::serialize::Layer::reg(const std::string& layerType, const LayerFnctSerializeType& fncts)
140 {
141  m_fncts[layerType] = fncts;
142 }
143 
144 te::map::AbstractLayer* te::map::serialize::Layer::read(te::xml::Reader& reader) const
145 {
146  std::string layerType = boost::to_upper_copy(reader.getElementLocalName());
147 
148  LayerFnctIdxType::const_iterator it = m_fncts.find(layerType);
149 
150  if(it == m_fncts.end())
151  throw Exception((boost::format(TE_TR("Could not find a reader for the following layer type: %1%.")) % layerType).str());
152 
153  assert(it->second.second);
154 
155  return it->second.first(reader);
156 }
157 
158 void te::map::serialize::Layer::write(const te::map::AbstractLayer* alayer, te::xml::AbstractWriter& writer) const
159 {
160  assert(alayer);
161 
162  LayerFnctIdxType::const_iterator it = m_fncts.find(alayer->getType());
163 
164  if(it == m_fncts.end())
165  throw Exception((boost::format(TE_TR("Could not find a writer for the following layer type: %1%.")) % alayer->getType()).str());
166 
167  assert(it->second.second);
168 
169  return it->second.second(alayer, writer);
170 }
171 
172 te::map::serialize::Layer::~Layer()
173 {
174 }
175 
176 te::map::serialize::Layer::Layer()
177 {
178  m_fncts["DATASETLAYER"] = std::make_pair(LayerReadFnctType(&DataSetLayerReader), LayerWriteFnctType(&DataSetLayerWriter));
179  m_fncts["QUERYLAYER"] = std::make_pair(LayerReadFnctType(&QueryLayerReader), LayerWriteFnctType(&QueryLayerWriter));
180  m_fncts["FOLDERLAYER"] = std::make_pair(LayerReadFnctType(&FolderLayerReader), LayerWriteFnctType(&FolderLayerWriter));
181  m_fncts["RASTERLAYER"] = std::make_pair(LayerReadFnctType(&RasterLayerReader), LayerWriteFnctType(&RasterLayerWriter));
182  m_fncts["DATASETADAPTERLAYER"] = std::make_pair(LayerReadFnctType(&DataSetAdapterLayerReader), LayerWriteFnctType(&DataSetAdapterLayerWriter));
183 }
184 
185 te::map::AbstractLayer* DataSetLayerReader(te::xml::Reader& reader)
186 {
187  std::string id = reader.getAttr("id");
188 
189  /* Title Element */
190  reader.next();
191  std::string title = te::map::serialize::ReadLayerTitle(reader);
192 
193  /* Visible Element */
194  reader.next();
195  std::string visible = te::map::serialize::ReadLayerVisibility(reader);
196 
197  reader.next();
198 
199  /* Grouping */
200  te::map::Grouping* grouping = te::map::serialize::ReadLayerGrouping(reader);
201 
202  /* Chart */
203  std::auto_ptr<te::map::Chart> chart(te::map::serialize::ReadLayerChart(reader));
204 
205  /* DataSetName Element */
206  assert(reader.getNodeType() == te::xml::START_ELEMENT);
207  assert(reader.getElementLocalName() == "DataSetName");
208  reader.next();
209  assert(reader.getNodeType() == te::xml::VALUE);
210  std::string dataset = reader.getElementValue();
211  reader.next();
212  assert(reader.getNodeType() == te::xml::END_ELEMENT);
213 
214  /* DataSourceId Element */
215  reader.next();
216  assert(reader.getNodeType() == te::xml::START_ELEMENT);
217  assert(reader.getElementLocalName() == "DataSourceId");
218  reader.next();
219  assert(reader.getNodeType() == te::xml::VALUE);
220  std::string datasourceId = reader.getElementValue();
221  reader.next();
222  assert(reader.getNodeType() == te::xml::END_ELEMENT);
223 
224  /* SRID Element */
225  reader.next();
226  assert(reader.getNodeType() == te::xml::START_ELEMENT);
227  assert(reader.getElementLocalName() == "SRID");
228  reader.next();
229  assert(reader.getNodeType() == te::xml::VALUE);
230  int srid = reader.getElementValueAsInt32();
231  reader.next();
232  assert(reader.getNodeType() == te::xml::END_ELEMENT);
233 
234  /* Extent Element */
235  reader.next();
236  assert(reader.getNodeType() == te::xml::START_ELEMENT);
237  assert(reader.getElementLocalName() == "Extent");
238  std::auto_ptr<te::gm::Envelope> mbr(te::serialize::xml::ReadExtent(reader));
239 
240  /* RendererId Element */
241  assert(reader.getNodeType() == te::xml::START_ELEMENT);
242  assert(reader.getElementLocalName() == "RendererId");
243  reader.next();
244  assert(reader.getNodeType() == te::xml::VALUE);
245  std::string rendererId = reader.getElementValue();
246  reader.next();
247  assert(reader.getNodeType() == te::xml::END_ELEMENT);
248 
249  /* Composition Mode Element */
250  reader.next();
251  int compositionMode = te::map::SourceOver;
252  if(reader.getNodeType() == te::xml::START_ELEMENT && reader.getElementLocalName() == "CompositionMode")
253  {
254  reader.next();
255  assert(reader.getNodeType() == te::xml::VALUE);
256  compositionMode = reader.getElementValueAsInt32();
257  reader.next();
258  assert(reader.getNodeType() == te::xml::END_ELEMENT);
259  reader.next();
260  }
261 
262  /* has a Style Element ? */
263  std::auto_ptr<te::se::Style> style;
264 
265  if((reader.getNodeType() == te::xml::START_ELEMENT) &&
266  (reader.getElementLocalName() == "Style"))
267  {
268  reader.next();
269  assert(reader.getNodeType() == te::xml::START_ELEMENT);
270 
271  style.reset(te::se::serialize::Style::getInstance().read(reader));
272 
273  assert(reader.getNodeType() == te::xml::END_ELEMENT);
274  assert(reader.getElementLocalName() == "Style");
275 
276  reader.next();
277  }
278 
279  assert(reader.getNodeType() == te::xml::END_ELEMENT);
280  assert(reader.getElementLocalName() == "DataSetLayer");
281 
282  reader.next();
283 
284  std::auto_ptr<te::map::DataSetLayer> layer(new te::map::DataSetLayer(id, title, 0));
285  layer->setSRID(srid);
286  layer->setExtent(*mbr.get());
287  layer->setVisibility(te::map::serialize::GetVisibility(visible));
288  layer->setDataSetName(dataset);
289  layer->setDataSourceId(datasourceId);
290  layer->setRendererType(rendererId);
291  layer->setCompositionMode((te::map::CompositionMode)compositionMode);
292  layer->setStyle(style.release());
293 
294  if(grouping)
295  layer->setGrouping(grouping);
296 
297  if(chart.get())
298  layer->setChart(chart.release());
299 
300  return layer.release();
301 }
302 
303 te::map::AbstractLayer* QueryLayerReader(te::xml::Reader& reader)
304 {
305  std::string id = reader.getAttr("id");
306 
307  /* Title Element */
308  reader.next();
309  std::string title = te::map::serialize::ReadLayerTitle(reader);
310 
311  /* Visible Element */
312  reader.next();
313  std::string visible = te::map::serialize::ReadLayerVisibility(reader);
314  reader.next();
315 
316  /* Grouping */
317  te::map::Grouping* grouping = te::map::serialize::ReadLayerGrouping(reader);
318 
319  /* Chart */
320  std::auto_ptr<te::map::Chart> chart(te::map::serialize::ReadLayerChart(reader));
321 
322  /* Query Element */
323  assert(reader.getNodeType() == te::xml::START_ELEMENT);
324  assert(reader.getElementLocalName() == "Select");
325  te::da::Select* query = te::serialize::xml::ReadSelect(reader);
326 
327  /* DataSourceId Element */
328  assert(reader.getNodeType() == te::xml::START_ELEMENT);
329  assert(reader.getElementLocalName() == "DataSourceId");
330  reader.next();
331  assert(reader.getNodeType() == te::xml::VALUE);
332  std::string datasourceId = reader.getElementValue();
333  reader.next();
334  assert(reader.getNodeType() == te::xml::END_ELEMENT);
335 
336  /* SRID Element */
337  reader.next();
338  assert(reader.getNodeType() == te::xml::START_ELEMENT);
339  assert(reader.getElementLocalName() == "SRID");
340  reader.next();
341  assert(reader.getNodeType() == te::xml::VALUE);
342  int srid = reader.getElementValueAsInt32();
343  reader.next();
344  assert(reader.getNodeType() == te::xml::END_ELEMENT);
345 
346  /* Extent Element */
347  reader.next();
348  assert(reader.getNodeType() == te::xml::START_ELEMENT);
349  assert(reader.getElementLocalName() == "Extent");
350  std::auto_ptr<te::gm::Envelope> mbr(te::serialize::xml::ReadExtent(reader));
351 
352  /* RendererId Element */
353  assert(reader.getNodeType() == te::xml::START_ELEMENT);
354  assert(reader.getElementLocalName() == "RendererId");
355  reader.next();
356  assert(reader.getNodeType() == te::xml::VALUE);
357  std::string rendererId = reader.getElementValue();
358  reader.next();
359  assert(reader.getNodeType() == te::xml::END_ELEMENT);
360 
361  /* Composition Mode Element */
362  reader.next();
363  int compositionMode = te::map::SourceOver;
364  if(reader.getNodeType() == te::xml::START_ELEMENT && reader.getElementLocalName() == "CompositionMode")
365  {
366  reader.next();
367  assert(reader.getNodeType() == te::xml::VALUE);
368  compositionMode = reader.getElementValueAsInt32();
369  reader.next();
370  assert(reader.getNodeType() == te::xml::END_ELEMENT);
371  reader.next();
372  }
373 
374  /* has a Style Element ? */
375  std::auto_ptr<te::se::Style> style;
376 
377  if((reader.getNodeType() == te::xml::START_ELEMENT) &&
378  (reader.getElementLocalName() == "Style"))
379  {
380  reader.next();
381  assert(reader.getNodeType() == te::xml::START_ELEMENT);
382 
383  style.reset(te::se::serialize::Style::getInstance().read(reader));
384 
385  assert(reader.getNodeType() == te::xml::END_ELEMENT);
386  assert(reader.getElementLocalName() == "Style");
387 
388  reader.next();
389  }
390 
391  assert(reader.getNodeType() == te::xml::END_ELEMENT);
392  assert(reader.getElementLocalName() == "QueryLayer");
393 
394  reader.next();
395 
396  std::auto_ptr<te::map::QueryLayer> layer(new te::map::QueryLayer(id, title, 0));
397  layer->setSRID(srid);
398  layer->setExtent(*mbr.get());
399  layer->setVisibility(te::map::serialize::GetVisibility(visible));
400  layer->setQuery(query);
401  layer->setDataSourceId(datasourceId);
402  layer->setRendererType(rendererId);
403  layer->setCompositionMode((te::map::CompositionMode)compositionMode);
404  layer->setStyle(style.release());
405 
406  if(grouping)
407  layer->setGrouping(grouping);
408 
409  if(chart.get())
410  layer->setChart(chart.release());
411 
412  return layer.release();
413 }
414 
415 te::map::AbstractLayer* FolderLayerReader(te::xml::Reader& reader)
416 {
417  std::string id = reader.getAttr("id");
418 
419  /* Title Element */
420  reader.next();
421  std::string title = te::map::serialize::ReadLayerTitle(reader);
422 
423  /* Visible Element */
424  reader.next();
425  std::string visible = te::map::serialize::ReadLayerVisibility(reader);
426 
427  reader.next();
428  assert(reader.getNodeType() == te::xml::START_ELEMENT);
429  assert(reader.getElementLocalName() == "LayerList");
430 
431  reader.next();
432 
433  std::auto_ptr<te::map::FolderLayer> flayer(new te::map::FolderLayer(id, title, 0));
434 
435  flayer->setVisibility(te::map::serialize::GetVisibility(visible));
436 
437  const te::map::serialize::Layer& lserial = te::map::serialize::Layer::getInstance();
438 
439  while((reader.getNodeType() != te::xml::END_ELEMENT) &&
440  (reader.getElementLocalName() != "LayerList"))
441  {
442  te::map::AbstractLayerPtr layer(lserial.read(reader));
443 
444  if(layer.get() == 0)
445  break;
446 
447  flayer->add(layer);
448  }
449 
450  reader.next();
451  assert(reader.getNodeType() == te::xml::END_ELEMENT);
452  assert(reader.getElementLocalName() == "FolderLayer");
453 
454  reader.next();
455 
456  return flayer.release();
457 }
458 
459 te::map::AbstractLayer* RasterLayerReader(te::xml::Reader& reader)
460 {
461  std::string id = reader.getAttr("id");
462 
463  /* Title Element */
464  reader.next();
465  std::string title = te::map::serialize::ReadLayerTitle(reader);
466 
467  /* Visible Element */
468  reader.next();
469  std::string visible = te::map::serialize::ReadLayerVisibility(reader);
470 
471  /* ConnectionInfo Element */
472  reader.next();
473  assert(reader.getNodeType() == te::xml::START_ELEMENT);
474  assert(reader.getElementLocalName() == "ConnectionInfo");
475 
476  std::map<std::string, std::string> conninfo;
477 
478  while(reader.next() &&
479  (reader.getNodeType() == te::xml::START_ELEMENT) &&
480  (reader.getElementLocalName() == "Parameter"))
481  {
482  // Parameter Name
483  reader.next();
484  assert(reader.getNodeType() == te::xml::START_ELEMENT);
485  assert(reader.getElementLocalName() == "Name");
486  reader.next();
487  assert(reader.getNodeType() == te::xml::VALUE);
488  std::string paramName = reader.getElementValue();
489  reader.next();
490  assert(reader.getNodeType() == te::xml::END_ELEMENT);
491 
492  // Parameter Value
493  reader.next();
494  assert(reader.getNodeType() == te::xml::START_ELEMENT);
495  assert(reader.getElementLocalName() == "Value");
496  reader.next();
497  assert(reader.getNodeType() == te::xml::VALUE);
498  std::string paramValue = reader.getElementValue();
499  reader.next();
500  assert(reader.getNodeType() == te::xml::END_ELEMENT);
501 
502  conninfo[paramName] = paramValue;
503 
504  reader.next();
505  assert(reader.getNodeType() == te::xml::END_ELEMENT);
506  }
507 
508  assert(reader.getNodeType() == te::xml::END_ELEMENT); // End of ConnectionInfo Element
509 
510  /* SRID Element */
511  reader.next();
512  assert(reader.getNodeType() == te::xml::START_ELEMENT);
513  assert(reader.getElementLocalName() == "SRID");
514  reader.next();
515  assert(reader.getNodeType() == te::xml::VALUE);
516  int srid = reader.getElementValueAsInt32();
517  reader.next();
518  assert(reader.getNodeType() == te::xml::END_ELEMENT);
519 
520  /* Extent Element */
521  reader.next();
522  assert(reader.getNodeType() == te::xml::START_ELEMENT);
523  assert(reader.getElementLocalName() == "Extent");
524  std::auto_ptr<te::gm::Envelope> mbr(te::serialize::xml::ReadExtent(reader));
525 
526  /* RendererId Element */
527  assert(reader.getNodeType() == te::xml::START_ELEMENT);
528  assert(reader.getElementLocalName() == "RendererId");
529  reader.next();
530  assert(reader.getNodeType() == te::xml::VALUE);
531  std::string rendererId = reader.getElementValue();
532  reader.next();
533  assert(reader.getNodeType() == te::xml::END_ELEMENT);
534 
535  /* Composition Mode Element */
536  reader.next();
537  int compositionMode = te::map::SourceOver;
538  if(reader.getNodeType() == te::xml::START_ELEMENT && reader.getElementLocalName() == "CompositionMode")
539  {
540  reader.next();
541  assert(reader.getNodeType() == te::xml::VALUE);
542  compositionMode = reader.getElementValueAsInt32();
543  reader.next();
544  assert(reader.getNodeType() == te::xml::END_ELEMENT);
545  reader.next();
546  }
547 
548  /* has a Style Element ? */
549  std::auto_ptr<te::se::Style> style;
550 
551  if((reader.getNodeType() == te::xml::START_ELEMENT) &&
552  (reader.getElementLocalName() == "Style"))
553  {
554  reader.next();
555  assert(reader.getNodeType() == te::xml::START_ELEMENT);
556 
557  style.reset(te::se::serialize::Style::getInstance().read(reader));
558 
559  assert(reader.getNodeType() == te::xml::END_ELEMENT);
560  assert(reader.getElementLocalName() == "Style");
561 
562  reader.next();
563  }
564 
565  assert(reader.getNodeType() == te::xml::END_ELEMENT);
566  assert(reader.getElementLocalName() == "RasterLayer");
567 
568  reader.next();
569 
570  std::auto_ptr<te::map::RasterLayer> layer(new te::map::RasterLayer(id, title, 0));
571  layer->setSRID(srid);
572  layer->setExtent(*mbr.get());
573  layer->setRasterInfo(conninfo);
574  layer->setVisibility(te::map::serialize::GetVisibility(visible));
575  layer->setRendererType(rendererId);
576  layer->setCompositionMode((te::map::CompositionMode)compositionMode);
577  layer->setStyle(dynamic_cast<te::se::CoverageStyle*>(style.release()));
578 
579  return layer.release();
580 }
581 
582 te::map::AbstractLayer* DataSetAdapterLayerReader(te::xml::Reader& reader)
583 {
584  std::string id = reader.getAttr("id");
585 
586  /* Title Element */
587  reader.next();
588  std::string title = te::map::serialize::ReadLayerTitle(reader);
589 
590  /* Visible Element */
591  reader.next();
592  std::string visible = te::map::serialize::ReadLayerVisibility(reader);
593 
594  reader.next();
595 
596  assert(reader.getNodeType() == te::xml::START_ELEMENT);
597  assert(reader.getElementLocalName() == "DataSetName");
598 
599  reader.next();
600 
601  assert(reader.getNodeType() == te::xml::VALUE);
602 
603  std::string dataSetName = reader.getElementValue();
604 
605  reader.next();
606 
607  assert(reader.getNodeType() == te::xml::END_ELEMENT); // DataSetName
608 
609  reader.next();
610 
611  assert(reader.getNodeType() == te::xml::START_ELEMENT);
612  assert(reader.getElementLocalName() == "DataSourceId");
613 
614  reader.next();
615 
616  assert(reader.getNodeType() == te::xml::VALUE);
617 
618  std::string dataSourceId = reader.getElementValue();
619 
620  reader.next();
621 
622  assert(reader.getNodeType() == te::xml::END_ELEMENT); // DataSourceId
623 
624  reader.next();
625 
626  assert(reader.getNodeType() == te::xml::START_ELEMENT);
627  assert(reader.getElementLocalName() == "RendererType");
628 
629  reader.next();
630 
631  assert(reader.getNodeType() == te::xml::VALUE);
632 
633  std::string rendererType = reader.getElementValue();
634 
635  reader.next();
636 
637  assert(reader.getNodeType() == te::xml::END_ELEMENT); //RendererType
638 
639  /* Composition Mode Element */
640  reader.next();
641  int compositionMode = te::map::SourceOver;
642  if(reader.getNodeType() == te::xml::START_ELEMENT && reader.getElementLocalName() == "CompositionMode")
643  {
644  reader.next();
645  assert(reader.getNodeType() == te::xml::VALUE);
646  compositionMode = reader.getElementValueAsInt32();
647  reader.next();
648  assert(reader.getNodeType() == te::xml::END_ELEMENT);
649  reader.next();
650  }
651 
652  /* has a Style Element ? */
653  std::auto_ptr<te::se::Style> style;
654 
655  if((reader.getNodeType() == te::xml::START_ELEMENT) &&
656  (reader.getElementLocalName() == "Style"))
657  {
658  reader.next();
659  assert(reader.getNodeType() == te::xml::START_ELEMENT);
660 
661  style.reset(te::se::serialize::Style::getInstance().read(reader));
662 
663  assert(reader.getNodeType() == te::xml::END_ELEMENT);
664  assert(reader.getElementLocalName() == "Style");
665 
666  reader.next();
667  }
668 
669  assert(reader.getNodeType() == te::xml::START_ELEMENT);
670  assert(reader.getElementLocalName() == "Converter");
671 
672  reader.next();
673 
674  assert(reader.getNodeType() == te::xml::START_ELEMENT);
675  assert(reader.getElementLocalName() == "InDataSetTypeName");
676 
677  reader.next();
678 
679  std::string inDataSetName = reader.getElementValue();
680 
681  reader.next();
682 
683  assert(reader.getNodeType() == te::xml::END_ELEMENT); // InDataSetTypeName
684 
685  reader.next();
686 
687  std::vector<std::pair<std::string, std::vector<std::size_t> > > props;
688 
689  while(reader.getNodeType() == te::xml::START_ELEMENT &&
690  reader.getElementLocalName() == "OutPropInfo")
691  {
692  reader.next();
693 
694  assert(reader.getNodeType() == te::xml::START_ELEMENT);
695  assert(reader.getElementLocalName() == "type");
696 
697  reader.next();
698 
699  assert(reader.getNodeType() == te::xml::VALUE);
700 
701  int type = reader.getElementValueAsInt32();
702 
703  reader.next();
704 
705  assert(reader.getNodeType() == te::xml::END_ELEMENT); // type
706 
707  reader.next();
708 
709  assert(reader.getNodeType() == te::xml::START_ELEMENT);
710  assert(reader.getElementLocalName() == "name");
711 
712  reader.next();
713 
714  assert(reader.getNodeType() == te::xml::VALUE);
715 
716  std::string name = reader.getElementValue();
717 
718  reader.next();
719 
720  assert(reader.getNodeType() == te::xml::END_ELEMENT); // name
721 
722  reader.next();
723 
724  int geomType;
725  int srid;
726 
727  assert(reader.getNodeType() == te::xml::START_ELEMENT);
728  assert(reader.getElementLocalName() == "geomType");
729 
730  reader.next();
731 
732  assert(reader.getNodeType() == te::xml::VALUE);
733 
734  geomType = reader.getElementValueAsInt32();
735 
736  reader.next();
737 
738  assert(reader.getNodeType() == te::xml::END_ELEMENT); // geomType
739 
740  reader.next();
741 
742  assert(reader.getNodeType() == te::xml::START_ELEMENT);
743  assert(reader.getElementLocalName() == "srid");
744 
745  reader.next();
746 
747  assert(reader.getNodeType() == te::xml::VALUE);
748 
749  srid = reader.getElementValueAsInt32();
750 
751  reader.next();
752 
753  assert(reader.getNodeType() == te::xml::END_ELEMENT); // srid
754 
755  reader.next();
756 
757  assert(reader.getNodeType() == te::xml::END_ELEMENT); // OutPropInfo
758 
759  reader.next();
760 
761  std::pair<std::string, std::vector<std::size_t> > prop;
762  prop.first = name;
763  std::vector<std::size_t> typeVec;
764  typeVec.push_back(type);
765  typeVec.push_back(geomType);
766  typeVec.push_back(srid);
767  prop.second = typeVec;
768  props.push_back(prop);
769  }
770 
771  std::vector<std::vector<std::size_t> > propertyIndexes;
772 
773  while(reader.getNodeType() == te::xml::START_ELEMENT &&
774  reader.getElementLocalName() == "PropertyIndex")
775  {
776 
777  int outIdx;
778  outIdx = reader.getAttrAsInt32("OutIdx");
779 
780  reader.next();
781 
782  std::vector<std::size_t> inIdxs;
783 
784  while(reader.getNodeType() == te::xml::START_ELEMENT &&
785  reader.getElementLocalName() == "InIdx")
786  {
787  reader.next();
788 
789  assert(reader.getNodeType() == te::xml::VALUE);
790 
791  inIdxs.push_back(reader.getElementValueAsInt32());
792 
793  reader.next();
794 
795  assert(reader.getNodeType() == te::xml::END_ELEMENT); // InIdx
796 
797  reader.next();
798  }
799 
800  assert(reader.getNodeType() == te::xml::END_ELEMENT); // InIdx
801 
802  propertyIndexes.push_back(inIdxs);
803 
804  reader.next();
805  }
806 
807  std::vector<std::string> functionsNames;
808 
809  int teste = 0;
810  while(reader.getNodeType() == te::xml::START_ELEMENT &&
811  reader.getElementLocalName() == "FunctionName")
812  {
813  ++teste;
814 
815  reader.next();
816 
817  assert(reader.getNodeType() == te::xml::VALUE);
818 
819  functionsNames.push_back(reader.getElementValue());
820 
821  reader.next();
822 
823  assert(reader.getNodeType() == te::xml::END_ELEMENT); // FunctionName
824 
825  reader.next();
826  }
827 
828  assert(reader.getNodeType() == te::xml::END_ELEMENT); // Converter
829 
830  reader.next();
831 
832  assert(reader.getNodeType() == te::xml::END_ELEMENT); // DataSetAdapterLayer
833 
834  reader.next();
835 
836  te::map::DataSetAdapterLayer* result = new te::map::DataSetAdapterLayer(id);
837  result->setTitle(title);
838 
839  result->setVisibility(te::map::serialize::GetVisibility(visible));
840  result->setDataSetName(dataSetName);
841  result->setDataSourceId(dataSourceId);
842  result->setRendererType(rendererType);
843  result->setCompositionMode((te::map::CompositionMode)compositionMode);
844  result->setStyle(style.release());
845 
846  te::da::DataSourcePtr ds = te::da::GetDataSource(dataSourceId);
847  std::auto_ptr<te::da::DataSetType> dst = ds->getDataSetType(dataSetName);
848 
849  std::auto_ptr<te::da::DataSetTypeConverter> converter(new te::da::DataSetTypeConverter(dst.get()));
850 
851  for(std::size_t i = 0; i < propertyIndexes.size(); ++i)
852  {
853  converter->add(propertyIndexes[i], GetProperty(props[i].first, props[i].second[0], props[i].second[1], props[i].second[2]), functionsNames[i]);
854  }
855 
856  std::vector<te::dt::Property*> convertedProps = converter->getResult()->getProperties();
857 
858  te::da::PrimaryKey* pkIn = dst->getPrimaryKey();
859  if(pkIn)
860  {
861  te::da::PrimaryKey* pk = new te::da::PrimaryKey(converter->getResult());
862 
863  std::vector<te::dt::Property*> pkProps = pkIn->getProperties();
864  for(std::size_t i = 0; i < convertedProps.size(); ++i)
865  {
866  for(std::size_t t = 0; t < pkProps.size(); ++t)
867  {
868  if(convertedProps[i]->getName() == pkProps[t]->getName())
869  pk->add(convertedProps[i]);
870 
871  }
872  }
873  }
874 
875  result->setConverter(converter);
876 
877  te::gm::Envelope* env = new te::gm::Envelope;
878 
879  std::auto_ptr<te::da::DataSet> dataset = result->getData();
880 
881  te::gm::GeometryProperty* gp = te::da::GetFirstGeomProperty(result->getConverter()->getResult());
882 
883  if(gp)
884  {
885  while(dataset->moveNext())
886  {
887  te::gm::Geometry* geom = dataset->getGeometry(gp->getName()).release();
888  assert(geom);
889  env->Union(*geom->getMBR());
890  }
891  }
892 
893  result->setExtent(*env);
894 
895  return result;
896 }
897 
898 void DataSetLayerWriter(const te::map::AbstractLayer* alayer, te::xml::AbstractWriter& writer)
899 {
900  const te::map::DataSetLayer* layer = dynamic_cast<const te::map::DataSetLayer*>(alayer);
901 
902  if(layer == 0)
903  return;
904 
905  writer.writeStartElement("te_map:DataSetLayer");
906 
907  te::map::serialize::WriteAbstractLayer(layer, writer);
908 
909  writer.writeElement("te_map:DataSetName", layer->getDataSetName());
910  writer.writeElement("te_map:DataSourceId", layer->getDataSourceId());
911  writer.writeElement("te_map:SRID", layer->getSRID());
912  te::serialize::xml::SaveExtent(layer->getExtent(), writer);
913  writer.writeElement("te_map:RendererId", layer->getRendererType());
914  writer.writeElement("te_map:CompositionMode", (int)layer->getCompositionMode());
915 
916  if(layer->getStyle())
917  {
918  writer.writeStartElement("te_map:Style");
919 
920  te::se::serialize::Style::getInstance().write(layer->getStyle(), writer);
921 
922  writer.writeEndElement("te_map:Style");
923  }
924 
925  writer.writeEndElement("te_map:DataSetLayer");
926 }
927 
928 void QueryLayerWriter(const te::map::AbstractLayer* alayer, te::xml::AbstractWriter& writer)
929 {
930  const te::map::QueryLayer* layer = dynamic_cast<const te::map::QueryLayer*>(alayer);
931 
932  if(layer == 0)
933  return;
934 
935  writer.writeStartElement("te_map:QueryLayer");
936 
937  te::map::serialize::WriteAbstractLayer(layer, writer);
938 
939  te::serialize::xml::Save(layer->getQuery(), writer);
940  writer.writeElement("te_map:DataSourceId", layer->getDataSourceId());
941  writer.writeElement("te_map:SRID", layer->getSRID());
942  te::serialize::xml::SaveExtent(layer->getExtent(), writer);
943  writer.writeElement("te_map:RendererId", layer->getRendererType());
944  writer.writeElement("te_map:CompositionMode", (int)layer->getCompositionMode());
945 
946  if(layer->getStyle())
947  {
948  writer.writeStartElement("te_map:Style");
949 
950  te::se::serialize::Style::getInstance().write(layer->getStyle(), writer);
951 
952  writer.writeEndElement("te_map:Style");
953  }
954 
955  writer.writeEndElement("te_map:QueryLayer");
956 }
957 
958 void FolderLayerWriter(const te::map::AbstractLayer* alayer, te::xml::AbstractWriter& writer)
959 {
960  const te::map::FolderLayer* folderLayer = static_cast<const te::map::FolderLayer*>(alayer);
961 
962  writer.writeStartElement("te_map:FolderLayer");
963 
964  writer.writeAttribute("id", folderLayer->getId());
965  writer.writeElement("te_map:Title", folderLayer->getTitle());
966  writer.writeElement("te_map:Visible", te::map::serialize::GetVisibility(folderLayer->getVisibility()));
967 
968  writer.writeStartElement("te_map:LayerList");
969 
970  size_t count = folderLayer->getChildrenCount();
971 
972  for(size_t i=0; i<count; i++)
973  te::map::serialize::Layer::getInstance().write((const te::map::AbstractLayer*) folderLayer->getChild(i).get(), writer);
974 
975  writer.writeEndElement("te_map:LayerList");
976 
977  writer.writeEndElement("te_map:FolderLayer");
978 }
979 
980 void RasterLayerWriter(const te::map::AbstractLayer* alayer, te::xml::AbstractWriter& writer)
981 {
982  const te::map::RasterLayer* layer = dynamic_cast<const te::map::RasterLayer*>(alayer);
983 
984  if(layer == 0)
985  return;
986 
987  writer.writeStartElement("te_map:RasterLayer");
988 
989  te::map::serialize::WriteAbstractLayer(layer, writer);
990 
991  writer.writeStartElement("te_map:ConnectionInfo");
992  std::map<std::string, std::string> info = layer->getRasterInfo();
993  std::map<std::string, std::string>::iterator conIt;
994 
995  for(conIt=info.begin(); conIt!=info.end(); ++conIt)
996  {
997  writer.writeStartElement("te_map:Parameter");
998 
999  writer.writeStartElement("te_map:Name");
1000  writer.writeValue(conIt->first);
1001  writer.writeEndElement("te_map:Name");
1002 
1003  writer.writeStartElement("te_map:Value");
1004  writer.writeValue(conIt->second);
1005  writer.writeEndElement("te_map:Value");
1006 
1007  writer.writeEndElement("te_map:Parameter");
1008  }
1009  writer.writeEndElement("te_map:ConnectionInfo");
1010 
1011  writer.writeElement("te_map:SRID", layer->getSRID());
1012  te::serialize::xml::SaveExtent(layer->getExtent(), writer);
1013  writer.writeElement("te_map:RendererId", layer->getRendererType());
1014  writer.writeElement("te_map:CompositionMode", (int)layer->getCompositionMode());
1015 
1016  if(layer->getStyle())
1017  {
1018  writer.writeStartElement("te_map:Style");
1019 
1020  te::se::serialize::Style::getInstance().write(layer->getStyle(), writer);
1021 
1022  writer.writeEndElement("te_map:Style");
1023  }
1024 
1025  writer.writeEndElement("te_map:RasterLayer");
1026 }
1027 
1028 void DataSetAdapterLayerWriter(const te::map::AbstractLayer* alayer, te::xml::AbstractWriter& writer)
1029 {
1030  const te::map::DataSetAdapterLayer* layer = dynamic_cast<const te::map::DataSetAdapterLayer*>(alayer);
1031 
1032  if(layer == 0)
1033  return;
1034 
1035  writer.writeStartElement("te_map:DataSetAdapterLayer");
1036 
1037  te::map::serialize::WriteAbstractLayer(layer, writer);
1038 
1039  writer.writeElement("te_map:DataSetName", layer->getDataSetName());
1040  writer.writeElement("te_map:DataSourceId", layer->getDataSourceId());
1041  writer.writeElement("te_map:RendererType", layer->getRendererType());
1042  writer.writeElement("te_map:CompositionMode", (int)layer->getCompositionMode());
1043 
1044  if(layer->getStyle())
1045  {
1046  writer.writeStartElement("te_map:Style");
1047 
1048  te::se::serialize::Style::getInstance().write(layer->getStyle(), writer);
1049 
1050  writer.writeEndElement("te_map:Style");
1051  }
1052 
1053  te::da::DataSetTypeConverter* converter = layer->getConverter();
1054 
1055  writer.writeStartElement("te_map:Converter");
1056 
1057  writer.writeElement("te_map:InDataSetTypeName", converter->getConvertee()->getName());
1058 
1059  te::da::DataSetType* resultDt = converter->getResult();
1060 
1061  std::vector<te::dt::Property*> outProps = resultDt->getProperties();
1062 
1063  for(std::size_t i = 0; i < outProps.size(); ++i)
1064  {
1065  writer.writeStartElement("te_map:OutPropInfo");
1066 
1067  writer.writeElement("te_map:type", outProps[i]->getType());
1068  writer.writeElement("te_map:name", outProps[i]->getName());
1069 
1070  if(outProps[i]->getType() == te::dt::GEOMETRY_TYPE)
1071  {
1072  te::gm::GeometryProperty* geomProp = dynamic_cast<te::gm::GeometryProperty*>(outProps[i]);
1073 
1074  writer.writeElement("te_map:geomType", geomProp->getGeometryType());
1075  writer.writeElement("te_map:srid", geomProp->getSRID());
1076  }
1077  else
1078  {
1079  writer.writeElement("te_map:geomType", -1);
1080  writer.writeElement("te_map:srid", 0);
1081  }
1082 
1083  writer.writeEndElement("te_map:OutPropInfo");
1084 
1085  }
1086 
1087  // PropertyIndexes
1088  std::vector<std::vector<std::size_t> > propertyIndexes = converter->getConvertedPropertyIndexes();
1089 
1090  for(std::size_t i = 0; i < propertyIndexes.size(); ++i)
1091  {
1092  writer.writeStartElement("te_map:PropertyIndex");
1093 
1094  writer.writeAttribute("OutIdx", (int)i);
1095 
1096  std::vector<std::size_t> inputPropertiesIdx = propertyIndexes[i];
1097 
1098  for(std::size_t j = 0; j < inputPropertiesIdx.size(); ++j)
1099  writer.writeElement("te_map:InIdx", (int)inputPropertiesIdx[j]);
1100 
1101  writer.writeEndElement("te_map:PropertyIndex");
1102  }
1103 
1104  std::vector<te::da::AttributeConverter> converters = converter->getConverters();
1105  for(std::size_t i = 0; i < converters.size(); ++i)
1106  {
1107  std::string convName = layer->getConverter()->getConverterName(i);
1108 
1109  writer.writeElement("te_map:FunctionName", convName);
1110  }
1111 
1112  writer.writeEndElement("te_map:Converter");
1113 
1114  writer.writeEndElement("te_map:DataSetAdapterLayer");
1115 }
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:262
te::map::AbstractLayer::getType
virtual const std::string & getType() const =0
It returns the layer type.
te::map::serialize::ReadLayerVisibility
TEMAPEXPORT std::string ReadLayerVisibility(te::xml::Reader &reader)
Definition: Utils.cpp:106
te::map::serialize::WriteAbstractLayer
TEMAPEXPORT void WriteAbstractLayer(const te::map::AbstractLayer *layer, te::xml::AbstractWriter &writer)
Definition: Utils.cpp:582
te::map::AbstractLayer::getId
virtual const std::string & getId() const
It returns the layer id.
Definition: AbstractLayer.cpp:86
DataSetAdapterLayerWriter
void DataSetAdapterLayerWriter(const te::map::AbstractLayer *layer, te::xml::AbstractWriter &writer)
Definition: Layer.cpp:1028
te::gm::GeometryProperty
Geometric property.
Definition: GeometryProperty.h:51
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
Utils.h
Utility functions for the data access module.
te::map::DataSetLayer::getDataSetName
const std::string & getDataSetName() const
Definition: DataSetLayer.cpp:208
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::da::DataSetTypeConverter::getConvertedPropertyIndexes
const std::vector< std::vector< std::size_t > > & getConvertedPropertyIndexes() const
Definition: DataSetTypeConverter.cpp:292
te::common::TreeItem::getChild
const TreeItemPtr & getChild(std::size_t i) const
It returns the n-th child.
Definition: TreeItem.cpp:75
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:218
te::da::DataSourcePtr
boost::shared_ptr< DataSource > DataSourcePtr
Definition: DataSource.h:1435
te::map::AbstractLayer::getTitle
virtual const std::string & getTitle() const
It returns the layer title.
Definition: AbstractLayer.cpp:96
te::map::serialize::ReadLayerChart
TEMAPEXPORT std::auto_ptr< te::map::Chart > ReadLayerChart(te::xml::Reader &reader)
Definition: Utils.cpp:290
te::xml::AbstractWriter::writeStartElement
virtual void writeStartElement(const std::string &qName)=0
DataSetLayerReader
te::map::AbstractLayer * DataSetLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:185
te::map::serialize::Layer::m_fncts
LayerFnctIdxType m_fncts
Definition: Layer.h:79
te::da::DataSetType
A class that models the description of a dataset.
Definition: DataSetType.h:72
te::xml::AbstractWriter::writeValue
virtual void writeValue(const std::string &value)=0
te::map::serialize::ReadLayerTitle
TEMAPEXPORT std::string ReadLayerTitle(te::xml::Reader &reader)
Definition: Utils.cpp:93
Layer.h
Auxiliary classes and functions to read layer information from a XML document.
te::map::AbstractLayer::setCompositionMode
void setCompositionMode(te::map::CompositionMode mode)
It sets the composition mode.
Definition: AbstractLayer.cpp:329
RasterLayerWriter
void RasterLayerWriter(const te::map::AbstractLayer *layer, te::xml::AbstractWriter &writer)
Definition: Layer.cpp:980
te::map::DataSetAdapterLayer::getConverter
te::da::DataSetTypeConverter * getConverter() const
It returns the DataSetTypeConverter.
Definition: DataSetAdapterLayer.cpp:228
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:142
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::xml::AbstractWriter
This class models a XML writer object.
Definition: AbstractWriter.h:49
TE_TR
#define TE_TR(message)
It marks a string in order to get translated.
Definition: Translator.h:347
te::map::AbstractLayer::setTitle
virtual void setTitle(const std::string &title)
It sets the layer title.
Definition: AbstractLayer.cpp:101
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:160
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::map::serialize::ReadLayerGrouping
TEMAPEXPORT te::map::Grouping * ReadLayerGrouping(te::xml::Reader &reader)
Definition: Utils.cpp:119
te::da::DataSetTypeConverter::getConvertee
DataSetType * getConvertee()
This method returns the pointer to the DataSetType that is handled by the converter.
Definition: DataSetTypeConverter.cpp:116
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::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:59
te::map::AbstractLayer::getCompositionMode
te::map::CompositionMode getCompositionMode() const
It returns the composition mode.
Definition: AbstractLayer.cpp:324
te::map::CompositionMode
CompositionMode
The composition mode used to render the canvas.
Definition: Enums.h:174
te::da::DataSetTypeConverter::getConverters
const std::vector< AttributeConverter > & getConverters() const
Definition: DataSetTypeConverter.cpp:297
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::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::xml::AbstractWriter::writeElement
virtual void writeElement(const std::string &qName, const std::string &value)=0
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:144
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< Style >::getInstance
static Style & getInstance()
It returns a reference to the singleton instance.
te::gm::Envelope
An Envelope defines a 2D rectangular region.
Definition: Envelope.h:51
te::map::DataSetLayer::getDataSourceId
const std::string & getDataSourceId() const
Definition: DataSetLayer.cpp:218
te::map::AbstractLayer::getStyle
virtual te::se::Style * getStyle() const
It returns the Style associated to the layer.
Definition: AbstractLayer.cpp:281
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:201
te::map::AbstractLayer::setVisibility
virtual void setVisibility(Visibility v)
It sets the layer visibility.
Definition: AbstractLayer.cpp:147
te::map::QueryLayer::getDataSourceId
const std::string & getDataSourceId() const
Definition: QueryLayer.cpp:352
te::serialize::xml::SaveExtent
TEGEOMEXPORT void SaveExtent(const te::gm::Envelope &e, te::xml::AbstractWriter &writer)
Definition: Serializer.cpp:52
QueryLayerReader
te::map::AbstractLayer * QueryLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:303
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:459
te::map::AbstractLayer::setExtent
virtual void setExtent(const te::gm::Envelope &mbr)
It sets the Layer extent (or minimum bounding box).
Definition: AbstractLayer.cpp:223
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:340
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
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
QueryLayerWriter
void QueryLayerWriter(const te::map::AbstractLayer *layer, te::xml::AbstractWriter &writer)
Definition: Layer.cpp:928
te::map::serialize::GetVisibility
TEMAPEXPORT te::map::Visibility GetVisibility(const std::string &visible)
Definition: Utils.cpp:42
te::xml::AbstractWriter::writeAttribute
virtual void writeAttribute(const std::string &attName, const std::string &value)=0
te::serialize::xml::ReadSelect
TEDATAACCESSEXPORT te::da::Select * ReadSelect(te::xml::Reader &reader)
Definition: Serializer.cpp:1986
te::da::PrimaryKey
It describes a primary key (pk) constraint.
Definition: PrimaryKey.h:52
te::map::serialize::Layer::write
void write(const te::map::AbstractLayer *alayer, te::xml::AbstractWriter &writer) const
Definition: Layer.cpp:158
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:47
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:83
te::map::AbstractLayer::setStyle
virtual void setStyle(te::se::Style *style)
It sets the Style associated to the layer.
Definition: AbstractLayer.cpp:286
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:362
FolderLayerReader
te::map::AbstractLayer * FolderLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:415
te::xml::AbstractWriter::writeEndElement
virtual void writeEndElement(const std::string &qName)=0
te::map::AbstractLayer::getSRID
virtual int getSRID() const
It returns the Spatial Reference System ID associated to the Layer.
Definition: AbstractLayer.cpp:228
te::map::DataSetLayer
A layer with reference to a dataset.
Definition: DataSetLayer.h:47
DataSetLayerWriter
void DataSetLayerWriter(const te::map::AbstractLayer *layer, te::xml::AbstractWriter &writer)
Definition: Layer.cpp:898
te::map::serialize::Layer::reg
void reg(const std::string &layerType, const LayerFnctSerializeType &fncts)
Definition: Layer.cpp:139
DataSetAdapterLayerReader
te::map::AbstractLayer * DataSetAdapterLayerReader(te::xml::Reader &reader)
Definition: Layer.cpp:582
te::da::GetFirstGeomProperty
TEDATAACCESSEXPORT te::gm::GeometryProperty * GetFirstGeomProperty(const DataSetType *dt)
Definition: Utils.cpp:557
te::map::AbstractLayerPtr
boost::intrusive_ptr< AbstractLayer > AbstractLayerPtr
Definition: AbstractLayer.h:522
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
te::map::serialize::Layer::LayerWriteFnctType
boost::function< void(const te::map::AbstractLayer *, te::xml::AbstractWriter &)> LayerWriteFnctType
Definition: Layer.h:61
te::gm::Geometry::getMBR
const Envelope * getMBR() const
It returns the minimum bounding rectangle for the geometry in an internal representation.
Definition: Geometry.cpp:104
FolderLayerWriter
void FolderLayerWriter(const te::map::AbstractLayer *layer, te::xml::AbstractWriter &writer)
Definition: Layer.cpp:958
te::map::DataSetLayer::getRendererType
const std::string & getRendererType() const
Definition: DataSetLayer.cpp:228
te::dt::Property::getName
const std::string & getName() const
It returns the property name.
Definition: Property.h:127