From b08f607f83722ab8918f60520ade597680a8e426 Mon Sep 17 00:00:00 2001 From: Andrew Bell Date: Thu, 18 Dec 2014 16:50:55 -0600 Subject: [PATCH] Use DimType in XMLDim. Minimize use of XMLDim. --- include/pdal/DbReader.hpp | 2 +- include/pdal/Dimension.hpp | 2 + include/pdal/XMLSchema.hpp | 39 ++++---- plugins/oci/io/OciCommon.cpp | 15 +--- plugins/oci/io/OciReader.cpp | 12 ++- plugins/oci/io/OciReader.hpp | 2 +- plugins/oci/io/OciWriter.cpp | 4 +- plugins/pgpointcloud/io/PgReader.cpp | 2 +- plugins/pgpointcloud/io/PgWriter.cpp | 6 +- plugins/sqlite/io/SQLiteReader.cpp | 3 +- plugins/sqlite/io/SQLiteWriter.cpp | 4 +- src/DbReader.cpp | 28 +++--- src/XMLSchema.cpp | 127 +++++++++++++++------------ test/unit/XMLSchemaTest.cpp | 21 +++-- 14 files changed, 141 insertions(+), 126 deletions(-) diff --git a/include/pdal/DbReader.hpp b/include/pdal/DbReader.hpp index 088014f946..8bf091ffe9 100644 --- a/include/pdal/DbReader.hpp +++ b/include/pdal/DbReader.hpp @@ -51,7 +51,7 @@ class PDAL_DLL DbReader : public Reader DimTypeList dbDimTypes() const; void loadSchema(PointContextRef ctx, const std::string& schemaString); void loadSchema(PointContextRef ctx, const XMLSchema& schema); - void writeField(PointBuffer& pb, const char *pos, XMLDim dim, + void writeField(PointBuffer& pb, const char *pos, const DimType& dim, PointId idx); void writePoint(PointBuffer& pb, PointId idx, const char *buf); diff --git a/include/pdal/Dimension.hpp b/include/pdal/Dimension.hpp index 480edab3e9..875e99b76f 100644 --- a/include/pdal/Dimension.hpp +++ b/include/pdal/Dimension.hpp @@ -751,6 +751,8 @@ inline Type::Enum type(std::string s) struct DimType { + DimType() : m_id(Dimension::Id::Unknown), m_type(Dimension::Type::None) + {} DimType(Dimension::Id::Enum id, Dimension::Type::Enum type) : m_id(id), m_type(type) {} diff --git a/include/pdal/XMLSchema.hpp b/include/pdal/XMLSchema.hpp index 78626b02f4..1738e6035a 100644 --- a/include/pdal/XMLSchema.hpp +++ b/include/pdal/XMLSchema.hpp @@ -63,10 +63,14 @@ namespace pdal void OCISchemaGenericErrorHandler(void * ctx, const char* message, ...); void OCISchemaStructuredErrorHandler(void * userData, xmlErrorPtr error); +class XMLSchema; + struct XMLDim { - XMLDim() : m_min(0.0), m_max(0.0), m_type(Dimension::Type::None), - m_id(Dimension::Id::Unknown) + friend class XMLSchema; + +public: + XMLDim() : m_min(0.0), m_max(0.0) {} std::string m_name; @@ -74,9 +78,7 @@ struct XMLDim uint32_t m_position; double m_min; double m_max; - XForm m_xform; - Dimension::Type::Enum m_type; - Dimension::Id::Enum m_id; + DimType m_dimType; }; typedef std::vector XMLDimList; inline bool operator < (const XMLDim& d1, const XMLDim& d2) @@ -85,25 +87,29 @@ inline bool operator < (const XMLDim& d1, const XMLDim& d2) class PDAL_DLL XMLSchema { public: - XMLSchema(Orientation::Enum orientation = Orientation::PointMajor) : - m_orientation(orientation) + XMLSchema(std::string xml, std::string xsd = "", + Orientation::Enum orientation = Orientation::PointMajor); + XMLSchema(const DimTypeList& dims, MetadataNode m = MetadataNode(), + Orientation::Enum orientation = Orientation::PointMajor); + XMLSchema() : m_orientation(Orientation::PointMajor) {} - ~XMLSchema(); - void read(std::string xml, std::string xsd = ""); + ~XMLSchema() + { xmlCleanupParser(); } + + std::string xml() const; DimTypeList dimTypes() const; - XMLDimList dims() const + XMLDimList xmlDims() const { return m_dims; } MetadataNode getMetadata() const { return m_metadata;} - std::string getXML(const DimTypeList& dims, - MetadataNode m = MetadataNode()); - std::string getXML(); + void setId(const std::string& name, Dimension::Id::Enum id) + { xmlDim(name).m_dimType.m_id = id; } void setXForm(Dimension::Id::Enum id, XForm xform) - { xmlDim(id).m_xform = xform; } + { xmlDim(id).m_dimType.m_xform = xform; } XForm xForm(Dimension::Id::Enum id) const - { return xmlDim(id).m_xform; } + { return xmlDim(id).m_dimType.m_xform; } void setOrientation(Orientation::Enum orientation) { m_orientation = orientation; } Orientation::Enum orientation() const @@ -117,12 +123,13 @@ class PDAL_DLL XMLSchema XMLDim& xmlDim(Dimension::Id::Enum id); const XMLDim& xmlDim(Dimension::Id::Enum id) const; + XMLDim& xmlDim(const std::string& name); xmlDocPtr init(const std::string& xml, const std::string& xsd); bool validate(xmlDocPtr doc, const std::string& xsd); std::string remapOldNames(const std::string& input); bool loadMetadata(xmlNode *startNode, MetadataNode& input); bool load(xmlDocPtr doc); - void write(xmlTextWriterPtr w, const DimTypeList& dims, MetadataNode m); + void writeXml(xmlTextWriterPtr w) const; }; } // namespace pdal diff --git a/plugins/oci/io/OciCommon.cpp b/plugins/oci/io/OciCommon.cpp index 95724d838d..4cb0cb04f8 100644 --- a/plugins/oci/io/OciCommon.cpp +++ b/plugins/oci/io/OciCommon.cpp @@ -129,13 +129,7 @@ XMLSchema fetchSchema(Statement stmt, BlockPtr block) } std::ostringstream fname; int cloudId = stmt->GetInteger(&(block->pc->pc_id)) ; -// fname << "schema-" << cloudId <<".xml"; -// std::ostream* out = FileUtils::createFile(fname.str()); -// out->write(pc_schema_xml.c_str(), pc_schema_xml.size()); -// FileUtils::closeFile(out); - XMLSchema schema; - schema.read(pc_schema_xml); - return schema; + return XMLSchema(pc_schema_xml); } @@ -171,12 +165,11 @@ void Block::update(XMLSchema *s) m_point_size = 0; // Wipe the size to reset m_num_remaining = num_points; m_schema.setOrientation(s->orientation()); - XMLDimList dims = s->dims(); + DimTypeList dims = s->dimTypes(); for (auto di = dims.begin(); di != dims.end(); ++di) { - Id::Enum id = m_ctx.findDim(di->m_name); - if (id == Id::X || id == Id::Y || id == Id::Z) - m_schema.setXForm(id, di->m_xform); + if (di->m_id == Id::X || di->m_id == Id::Y || di->m_id == Id::Z) + m_schema.setXForm(di->m_id, di->m_xform); m_point_size += Dimension::size(di->m_type); } } diff --git a/plugins/oci/io/OciReader.cpp b/plugins/oci/io/OciReader.cpp index 531819a9ae..d8a83b61ad 100644 --- a/plugins/oci/io/OciReader.cpp +++ b/plugins/oci/io/OciReader.cpp @@ -249,8 +249,7 @@ void OciReader::addDimensions(PointContextRef ctx) if (m_schemaFile.size()) { - std::string pcSchema = - m_block->m_schema.getXML(m_block->m_schema.dimTypes()); + std::string pcSchema = m_block->m_schema.xml(); std::ostream *out = FileUtils::createFile(m_schemaFile); out->write(pcSchema.c_str(), pcSchema.size()); FileUtils::closeFile(out); @@ -294,7 +293,7 @@ point_count_t OciReader::readDimMajor(PointBuffer& buffer, BlockPtr block, point_count_t blockRemaining; point_count_t numRead = 0; - XMLDimList dims = block->m_schema.dims(); + DimTypeList dims = block->m_schema.dimTypes(); for (auto di = dims.begin(); di != dims.end(); ++di) { PointId nextId = startId; @@ -325,7 +324,6 @@ point_count_t OciReader::readPointMajor(PointBuffer& buffer, PointId nextId = buffer.size(); point_count_t numRead = 0; - XMLDimList dims = block->m_schema.dims(); char *pos = seekPointMajor(block); while (numRead < numPts && numRemaining > 0) { @@ -340,10 +338,10 @@ point_count_t OciReader::readPointMajor(PointBuffer& buffer, } -char *OciReader::seekDimMajor(const XMLDim& d, BlockPtr block) +char *OciReader::seekDimMajor(const DimType& d, BlockPtr block) { size_t size = 0; - XMLDimList dims = block->m_schema.dims(); + DimTypeList dims = block->m_schema.dimTypes(); for (auto di = dims.begin(); di->m_id != d.m_id; ++di) size += Dimension::size(di->m_type); return block->data() + @@ -373,7 +371,7 @@ bool OciReader::readOci(Statement stmt, BlockPtr block) // Read the points from the blob in the row. readBlob(stmt, block); XMLSchema *s = findSchema(stmt, block); - m_dims = s->dims(); + m_dims = s->xmlDims(); block->update(s); block->clearFetched(); return true; diff --git a/plugins/oci/io/OciReader.hpp b/plugins/oci/io/OciReader.hpp index 368601b4b2..6abb61d691 100644 --- a/plugins/oci/io/OciReader.hpp +++ b/plugins/oci/io/OciReader.hpp @@ -76,7 +76,7 @@ class PDAL_DLL OciReader : public DbReader point_count_t numPts); point_count_t readPointMajor(PointBuffer& buffer, BlockPtr block, point_count_t numPts); - char *seekDimMajor(const XMLDim& d, BlockPtr block); + char *seekDimMajor(const DimType& d, BlockPtr block); char *seekPointMajor(BlockPtr block); bool readOci(Statement stmt, BlockPtr block); XMLSchema *findSchema(Statement stmt, BlockPtr block); diff --git a/plugins/oci/io/OciWriter.cpp b/plugins/oci/io/OciWriter.cpp index dac9e19b31..dcd6e39de9 100644 --- a/plugins/oci/io/OciWriter.cpp +++ b/plugins/oci/io/OciWriter.cpp @@ -547,8 +547,8 @@ void OciWriter::createPCEntry() s_geom << "," << bounds.maxy; s_geom << "))"; - XMLSchema schema(m_orientation); - std::string schemaData = schema.getXML(dbDimTypes()); + XMLSchema schema(dbDimTypes(), MetadataNode(), m_orientation); + std::string schemaData = schema.xml(); oss << "declare\n" " pc_id NUMBER := :" << nPCPos << ";\n" diff --git a/plugins/pgpointcloud/io/PgReader.cpp b/plugins/pgpointcloud/io/PgReader.cpp index e79a0bc382..a3b893142b 100644 --- a/plugins/pgpointcloud/io/PgReader.cpp +++ b/plugins/pgpointcloud/io/PgReader.cpp @@ -242,7 +242,7 @@ void PgReader::ready(PointContextRef ctx) m_point_size = 0; for (auto di = m_dims.begin(); di != m_dims.end(); ++di) - m_point_size += Dimension::size(di->m_type); + m_point_size += Dimension::size(di->m_dimType.m_type); CursorSetup(); } diff --git a/plugins/pgpointcloud/io/PgWriter.cpp b/plugins/pgpointcloud/io/PgWriter.cpp index 1a2873113c..daf1f7772d 100644 --- a/plugins/pgpointcloud/io/PgWriter.cpp +++ b/plugins/pgpointcloud/io/PgWriter.cpp @@ -280,8 +280,8 @@ uint32_t PgWriter::SetupSchema(uint32_t srid) MetadataNode m = metadata.getNode(); m.add("compression", compression); - XMLSchema schema; - std::string xml = schema.getXML(dbDimTypes(), m); + XMLSchema schema(dbDimTypes(), m); + std::string xml = schema.xml(); // Do any of the existing schemas match the one we want to use? if (schema_count > 0) @@ -315,8 +315,6 @@ uint32_t PgWriter::SetupSchema(uint32_t srid) pcid = atoi(pcid_str); } - - const char* paramValues = xml.c_str(); oss << "INSERT INTO pointcloud_formats (pcid, srid, schema) " "VALUES (" << pcid << "," << srid << ",$1)"; diff --git a/plugins/sqlite/io/SQLiteReader.cpp b/plugins/sqlite/io/SQLiteReader.cpp index 021f9b6737..fce03b8745 100644 --- a/plugins/sqlite/io/SQLiteReader.cpp +++ b/plugins/sqlite/io/SQLiteReader.cpp @@ -191,8 +191,7 @@ void SQLiteReader::addDimensions(PointContextRef ctx) FileUtils::closeFile(out); } - XMLSchema schema; - schema.read(s.data); + XMLSchema schema(s.data); m_patch->m_metadata = schema.getMetadata(); m_patch->m_ctx = ctx; diff --git a/plugins/sqlite/io/SQLiteWriter.cpp b/plugins/sqlite/io/SQLiteWriter.cpp index 5017a384fa..7554efb2c4 100644 --- a/plugins/sqlite/io/SQLiteWriter.cpp +++ b/plugins/sqlite/io/SQLiteWriter.cpp @@ -455,8 +455,8 @@ void SQLiteWriter::CreateCloud() m.add("compression", "lazperf"); m.add("version", "1.0"); } - XMLSchema schema; - std::string xml = schema.getXML(dbDimTypes(), m); + XMLSchema schema(dbDimTypes(), m); + std::string xml = schema.xml(); records rs; row r; diff --git a/src/DbReader.cpp b/src/DbReader.cpp index 32e9b770bd..3820b3e8cf 100644 --- a/src/DbReader.cpp +++ b/src/DbReader.cpp @@ -38,14 +38,13 @@ namespace pdal void DbReader::loadSchema(PointContextRef ctx, const std::string& schemaString) { - XMLSchema schema; - schema.read(schemaString); + XMLSchema schema(schemaString); loadSchema(ctx, schema); } void DbReader::loadSchema(PointContextRef ctx, const XMLSchema& schema) { - m_dims = schema.dims(); + m_dims = schema.xmlDims(); // Override XYZ to doubles and use those going forward // we will apply any scaling set before handing it off @@ -57,8 +56,9 @@ void DbReader::loadSchema(PointContextRef ctx, const XMLSchema& schema) m_packedPointSize = 0; for (auto di = m_dims.begin(); di != m_dims.end(); ++di) { - di->m_id = ctx.registerOrAssignDim(di->m_name, di->m_type); - m_packedPointSize += Dimension::size(di->m_type); + di->m_dimType.m_id = + ctx.registerOrAssignDim(di->m_name, di->m_dimType.m_type); + m_packedPointSize += Dimension::size(di->m_dimType.m_type); } } @@ -68,12 +68,12 @@ DimTypeList DbReader::dbDimTypes() const DimTypeList dimTypes; for (auto di = m_dims.begin(); di != m_dims.end(); ++di) - dimTypes.push_back(DimType(di->m_id, di->m_type, di->m_xform)); + dimTypes.push_back(di->m_dimType); return dimTypes; } -void DbReader::writeField(PointBuffer& pb, const char *pos, XMLDim dim, +void DbReader::writeField(PointBuffer& pb, const char *pos, const DimType& dim, PointId idx) { using namespace Dimension; @@ -102,20 +102,22 @@ void DbReader::writePoint(PointBuffer& pb, PointId idx, const char *buf) for (auto di = m_dims.begin(); di != m_dims.end(); ++di) { + DimType dimType = di->m_dimType; // If we read X, Y or Z as a signed 32, apply the transform and write // the transformed value (double). - if (di->m_type == Type::Signed32 && - (di->m_id == Id::X || di->m_id == Id::Y || di->m_id == Id::Z)) + if (dimType.m_type == Type::Signed32 && + (dimType.m_id == Id::X || dimType.m_id == Id::Y || + dimType.m_id == Id::Z)) { int32_t i; memcpy(&i, buf, sizeof(int32_t)); - double d = (i * di->m_xform.m_scale) + di->m_xform.m_offset; - pb.setField(di->m_id, idx, d); + double d = (i * dimType.m_xform.m_scale) + dimType.m_xform.m_offset; + pb.setField(dimType.m_id, idx, d); } else - pb.setField(di->m_id, di->m_type, idx, buf); - buf += Dimension::size(di->m_type); + pb.setField(dimType.m_id, dimType.m_type, idx, buf); + buf += Dimension::size(dimType.m_type); } } diff --git a/src/XMLSchema.cpp b/src/XMLSchema.cpp index d287e332dc..aba9bbdc72 100644 --- a/src/XMLSchema.cpp +++ b/src/XMLSchema.cpp @@ -162,31 +162,66 @@ void OCISchemaGenericErrorHandler std::cerr << "Generic error: '" << error << "'" << std::endl; } +XMLSchema::XMLSchema(std::string xml, std::string xsd, + Orientation::Enum orientation) : m_orientation(orientation) +{ + xmlDocPtr doc = init(xml, xsd); + if (doc) + { + load(doc); + xmlFreeDoc(doc); + } +} -XMLSchema::~XMLSchema() + +XMLSchema::XMLSchema(const DimTypeList& dims, MetadataNode m, + Orientation::Enum orientation) : m_orientation(orientation), m_metadata(m) { - xmlCleanupParser(); + for (auto di = dims.begin(); di != dims.end(); ++di) + { + XMLDim dim; + dim.m_dimType = *di; + m_dims.push_back(dim); + } } -DimTypeList XMLSchema::dimTypes() const +std::string XMLSchema::xml() const { - DimTypeList dimTypes; + xmlBuffer *b = xmlBufferCreate(); + xmlTextWriterPtr w = xmlNewTextWriterMemory(b, 0); - for (auto di = m_dims.begin(); di != m_dims.end(); ++di) - dimTypes.push_back(DimType(di->m_id, di->m_type, di->m_xform)); - return dimTypes; + xmlTextWriterSetIndent(w, 1); + xmlTextWriterStartDocument(w, NULL, "utf-8", NULL); + xmlTextWriterStartElementNS(w, (const xmlChar*)"pc", + (const xmlChar*)"PointCloudSchema", NULL); + xmlTextWriterWriteAttributeNS(w, (const xmlChar*) "xmlns", + (const xmlChar*)"pc", NULL, + (const xmlChar*)"http://pointcloud.org/schemas/PC/"); + xmlTextWriterWriteAttributeNS(w, (const xmlChar*)"xmlns", + (const xmlChar*)"xsi", NULL, + (const xmlChar*)"http://www.w3.org/2001/XMLSchema-instance"); + + writeXml(w); + + xmlTextWriterEndElement(w); + xmlTextWriterEndDocument(w); + + std::string output((const char *)b->content, b->use); + xmlFreeTextWriter(w); + xmlBufferFree(b); + + return output; } -void XMLSchema::read(std::string xml, std::string xsd) +DimTypeList XMLSchema::dimTypes() const { - xmlDocPtr doc = init(xml, xsd); - if (doc) - { - load(doc); - xmlFreeDoc(doc); - } + DimTypeList dimTypes; + + for (auto di = m_dims.begin(); di != m_dims.end(); ++di) + dimTypes.push_back(di->m_dimType); + return dimTypes; } @@ -381,7 +416,7 @@ bool XMLSchema::load(xmlDocPtr doc) std::cerr << "Unable to fetch interpretation.\n"; return false; } - dim.m_type = Dimension::type((const char*)n); + dim.m_dimType.m_type = Dimension::type((const char*)n); xmlFree(n); } if (boost::iequals((const char*)properties->name, "minimum")) @@ -414,7 +449,7 @@ bool XMLSchema::load(xmlDocPtr doc) std::cerr << "Unable to fetch offset value!"; return false; } - dim.m_xform.m_offset = std::atof((const char*)n); + dim.m_dimType.m_xform.m_offset = std::atof((const char*)n); xmlFree(n); } if (boost::iequals((const char*)properties->name, "scale")) @@ -425,7 +460,7 @@ bool XMLSchema::load(xmlDocPtr doc) std::cerr << "Unable to fetch scale value!"; return false; } - dim.m_xform.m_scale = std::atof((const char*)n); + dim.m_dimType.m_xform.m_scale = std::atof((const char*)n); xmlFree(n); } } @@ -436,62 +471,43 @@ bool XMLSchema::load(xmlDocPtr doc) } -std::string XMLSchema::getXML(const DimTypeList& dims, MetadataNode m) +XMLDim& XMLSchema::xmlDim(Dimension::Id::Enum id) { - xmlBuffer *b = xmlBufferCreate(); - xmlTextWriterPtr w = xmlNewTextWriterMemory(b, 0); - - xmlTextWriterSetIndent(w, 1); - xmlTextWriterStartDocument(w, NULL, "utf-8", NULL); - xmlTextWriterStartElementNS(w, (const xmlChar*)"pc", - (const xmlChar*)"PointCloudSchema", NULL); - xmlTextWriterWriteAttributeNS(w, (const xmlChar*) "xmlns", - (const xmlChar*)"pc", NULL, - (const xmlChar*)"http://pointcloud.org/schemas/PC/"); - xmlTextWriterWriteAttributeNS(w, (const xmlChar*)"xmlns", - (const xmlChar*)"xsi", NULL, - (const xmlChar*)"http://www.w3.org/2001/XMLSchema-instance"); - - write(w, dims, m); - - xmlTextWriterEndElement(w); - xmlTextWriterEndDocument(w); - - std::string output((const char *)b->content, b->use); - xmlFreeTextWriter(w); - xmlBufferFree(b); + static XMLDim nullDim; - return output; + for (auto di = m_dims.begin(); di != m_dims.end(); ++di) + if (di->m_dimType.m_id == id) + return *di; + return nullDim; } -XMLDim& XMLSchema::xmlDim(Dimension::Id::Enum id) +const XMLDim& XMLSchema::xmlDim(Dimension::Id::Enum id) const { static XMLDim nullDim; for (auto di = m_dims.begin(); di != m_dims.end(); ++di) - if (di->m_id == id) + if (di->m_dimType.m_id == id) return *di; return nullDim; } -const XMLDim& XMLSchema::xmlDim(Dimension::Id::Enum id) const +XMLDim& XMLSchema::xmlDim(const std::string& name) { static XMLDim nullDim; for (auto di = m_dims.begin(); di != m_dims.end(); ++di) - if (di->m_id == id) + if (di->m_name == name) return *di; return nullDim; } -void XMLSchema::write(xmlTextWriterPtr w, const DimTypeList& dims, - MetadataNode m) +void XMLSchema::writeXml(xmlTextWriterPtr w) const { int pos = 0; - for (auto di = dims.begin(); di != dims.end(); ++di, ++pos) + for (auto di = m_dims.begin(); di != m_dims.end(); ++di, ++pos) { xmlTextWriterStartElementNS(w, (const xmlChar*)"pc", (const xmlChar*)"dimension", NULL); @@ -503,17 +519,17 @@ void XMLSchema::write(xmlTextWriterPtr w, const DimTypeList& dims, (const xmlChar*)position.str().c_str()); std::ostringstream size; - size << Dimension::size(di->m_type); + size << Dimension::size(di->m_dimType.m_type); xmlTextWriterWriteElementNS(w, (const xmlChar*)"pc", (const xmlChar*)"size", NULL, (const xmlChar*)size.str().c_str()); - std::string description = Dimension::description(di->m_id); + std::string description = Dimension::description(di->m_dimType.m_id); if (description.size()) xmlTextWriterWriteElementNS(w, (const xmlChar*)"pc", (const xmlChar*)"description", NULL, (const xmlChar*)description.c_str()); - XForm xform = di->m_xform; + XForm xform = di->m_dimType.m_xform; if (xform.nonstandard()) { xmlTextWriterWriteElementNS(w, (const xmlChar*)"pc", @@ -524,14 +540,15 @@ void XMLSchema::write(xmlTextWriterPtr w, const DimTypeList& dims, (const xmlChar *)std::to_string(xform.m_offset).c_str()); } - std::string name = Dimension::name(di->m_id); + std::string name = Dimension::name(di->m_dimType.m_id); if (name.size()) xmlTextWriterWriteElementNS(w, (const xmlChar*)"pc", (const xmlChar*)"name", NULL, (const xmlChar*)name.c_str()); xmlTextWriterWriteElementNS(w, (const xmlChar*)"pc", (const xmlChar*)"interpretation", NULL, - (const xmlChar*) Dimension::interpretationName(di->m_type).c_str()); + (const xmlChar*) + Dimension::interpretationName(di->m_dimType.m_type).c_str()); xmlTextWriterWriteElementNS(w, (const xmlChar*)"pc", (const xmlChar*)"active", NULL, (const xmlChar*)"true"); @@ -548,13 +565,13 @@ void XMLSchema::write(xmlTextWriterPtr w, const DimTypeList& dims, (const xmlChar*)"orientation", NULL, (const xmlChar*)orientation.str().c_str()); - if (!m.empty()) + if (!m_metadata.empty()) { xmlTextWriterStartElementNS(w, (const xmlChar*) "pc", (const xmlChar*) "metadata", NULL); boost::property_tree::ptree output; - PipelineWriter::writeMetadata(output, m); + PipelineWriter::writeMetadata(output, m_metadata); std::ostringstream oss; boost::property_tree::xml_parser::write_xml(oss, output); std::string xml = oss.str(); diff --git a/test/unit/XMLSchemaTest.cpp b/test/unit/XMLSchemaTest.cpp index 662aa9b146..8ab3e0f50e 100644 --- a/test/unit/XMLSchemaTest.cpp +++ b/test/unit/XMLSchemaTest.cpp @@ -77,15 +77,15 @@ TEST(XMLSchemaTest, test_schema_read) ReadXML(TestConfig::g_data_path+"../../schemas/8-dimension-schema.xml"); std::string xsd = ReadXML(TestConfig::g_data_path+"../../schemas/LAS.xsd"); - XMLSchema s1; - s1.read(xml, xsd); + XMLSchema s1(xml, xsd); PointContext ctx; - XMLDimList dims = s1.dims(); + XMLDimList dims = s1.xmlDims(); for (auto di = dims.begin(); di != dims.end(); ++di) { - XMLDim& dim = *di; - dim.m_id = ctx.registerOrAssignDim(dim.m_name, dim.m_type); + Dimension::Id::Enum id = + ctx.registerOrAssignDim(di->m_name, di->m_dimType.m_type); + s1.setId(di->m_name, id); } MetadataNode m; @@ -95,12 +95,11 @@ TEST(XMLSchemaTest, test_schema_read) MetadataNode m1prime = m.add("m1prime", "Some other metadata"); m1.add("uuid", boost::uuids::nil_uuid()); - XMLSchema s2; - std::string xml_output = s2.getXML(s1.dimTypes(), m); + XMLSchema s2(s1.dimTypes(), m);; + std::string xml_output = s2.xml(); - XMLSchema s3; - s3.read(xml_output, xsd); - XMLDimList dims3 = s3.dims(); + XMLSchema s3(xml_output, xsd); + XMLDimList dims3 = s3.xmlDims(); EXPECT_EQ(dims.size(), dims3.size()); @@ -112,7 +111,7 @@ TEST(XMLSchemaTest, test_schema_read) XMLDim& dim3 = *di3; EXPECT_EQ(dim1.m_name, dim3.m_name); - EXPECT_EQ(dim1.m_type, dim3.m_type); + EXPECT_EQ(dim1.m_dimType.m_type, dim3.m_dimType.m_type); di1++; di3++; }