react-native-nitro-xlsx 0.2.5 → 0.2.6

package/thirdparty/pugixml/docs/samples/character.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<network>
+	<animation clip="idle" flags="loop" />
+	<animation clip="run" flags="loop" />
+	<animation clip="attack" />
+
+	<?include transitions.xml?>
+</network>

package/thirdparty/pugixml/docs/samples/custom_memory_management.cpp

@@ -0,0 +1,27 @@
+#include "pugixml.hpp"
+
+#include <new>
+
+// tag::decl[]
+void* custom_allocate(size_t size)
+{
+    return new (std::nothrow) char[size];
+}
+
+void custom_deallocate(void* ptr)
+{
+    delete[] static_cast<char*>(ptr);
+}
+// end::decl[]
+
+int main()
+{
+// tag::call[]
+    pugi::set_memory_management_functions(custom_allocate, custom_deallocate);
+// end::call[]
+
+    pugi::xml_document doc;
+    doc.load_string("<node/>");
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/include.cpp

@@ -0,0 +1,64 @@
+#include "pugixml.hpp"
+
+#include <string.h>
+#include <iostream>
+
+// tag::code[]
+bool load_preprocess(pugi::xml_document& doc, const char* path);
+
+bool preprocess(pugi::xml_node node)
+{
+    for (pugi::xml_node child = node.first_child(); child; )
+    {
+        if (child.type() == pugi::node_pi && strcmp(child.name(), "include") == 0)
+        {
+            pugi::xml_node include = child;
+
+            // load new preprocessed document (note: ideally this should handle relative paths)
+            const char* path = include.value();
+
+            pugi::xml_document doc;
+            if (!load_preprocess(doc, path)) return false;
+
+            // insert the comment marker above include directive
+            node.insert_child_before(pugi::node_comment, include).set_value(path);
+
+            // copy the document above the include directive (this retains the original order!)
+            for (pugi::xml_node ic = doc.first_child(); ic; ic = ic.next_sibling())
+            {
+                node.insert_copy_before(ic, include);
+            }
+
+            // remove the include node and move to the next child
+            child = child.next_sibling();
+
+            node.remove_child(include);
+        }
+        else
+        {
+            if (!preprocess(child)) return false;
+
+            child = child.next_sibling();
+        }
+    }
+
+    return true;
+}
+
+bool load_preprocess(pugi::xml_document& doc, const char* path)
+{
+    pugi::xml_parse_result result = doc.load_file(path, pugi::parse_default | pugi::parse_pi); // for <?include?>
+
+    return result ? preprocess(doc) : false;
+}
+// end::code[]
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!load_preprocess(doc, "character.xml")) return -1;
+
+    doc.print(std::cout);
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/load_error_handling.cpp

@@ -0,0 +1,33 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+void check_xml(const char* source)
+{
+// tag::code[]
+    pugi::xml_document doc;
+    pugi::xml_parse_result result = doc.load_string(source);
+
+    if (result)
+    {
+        std::cout << "XML [" << source << "] parsed without errors, attr value: [" << doc.child("node").attribute("attr").value() << "]\n\n";
+    }
+    else
+    {
+        std::cout << "XML [" << source << "] parsed with errors, attr value: [" << doc.child("node").attribute("attr").value() << "]\n";
+        std::cout << "Error description: " << result.description() << "\n";
+        std::cout << "Error offset: " << result.offset << " (error at [..." << (source + result.offset) << "]\n\n";
+    }
+// end::code[]
+}
+
+int main()
+{
+    check_xml("<node attr='value'><child>text</child></node>");
+    check_xml("<node attr='value'><child>text</chil></node>");
+    check_xml("<node attr='value'><child>text</child>");
+    check_xml("<node attr='value\"><child>text</child></node>");
+    check_xml("<node attr='value'><#tag /></node>");
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/load_file.cpp

@@ -0,0 +1,16 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+// tag::code[]
+    pugi::xml_document doc;
+
+    pugi::xml_parse_result result = doc.load_file("tree.xml");
+
+    std::cout << "Load result: " << result.description() << ", mesh name: " << doc.child("mesh").attribute("name").value() << std::endl;
+// end::code[]
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/load_memory.cpp

@@ -0,0 +1,66 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+#include <cstring>
+
+int main()
+{
+// tag::decl[]
+    const char source[] = "<mesh name='sphere'><bounds>0 0 1 1</bounds></mesh>";
+    size_t size = sizeof(source);
+// end::decl[]
+
+    pugi::xml_document doc;
+
+    {
+    // tag::load_buffer[]
+        // You can use load_buffer to load document from immutable memory block:
+        pugi::xml_parse_result result = doc.load_buffer(source, size);
+    // end::load_buffer[]
+
+        std::cout << "Load result: " << result.description() << ", mesh name: " << doc.child("mesh").attribute("name").value() << std::endl;
+    }
+
+    {
+    // tag::load_buffer_inplace_begin[]
+        // You can use load_buffer_inplace to load document from mutable memory block; the block's lifetime must exceed that of document
+        char* buffer = new char[size];
+        memcpy(buffer, source, size);
+
+        // The block can be allocated by any method; the block is modified during parsing
+        pugi::xml_parse_result result = doc.load_buffer_inplace(buffer, size);
+    // end::load_buffer_inplace_begin[]
+
+        std::cout << "Load result: " << result.description() << ", mesh name: " << doc.child("mesh").attribute("name").value() << std::endl;
+
+    // tag::load_buffer_inplace_end[]
+        // You have to destroy the block yourself after the document is no longer used
+        delete[] buffer;
+    // end::load_buffer_inplace_end[]
+    }
+
+    {
+    // tag::load_buffer_inplace_own[]
+        // You can use load_buffer_inplace_own to load document from mutable memory block and to pass the ownership of this block
+        // The block has to be allocated via pugixml allocation function - using i.e. operator new here is incorrect
+        char* buffer = static_cast<char*>(pugi::get_memory_allocation_function()(size));
+        memcpy(buffer, source, size);
+
+        // The block will be deleted by the document
+        pugi::xml_parse_result result = doc.load_buffer_inplace_own(buffer, size);
+    // end::load_buffer_inplace_own[]
+
+        std::cout << "Load result: " << result.description() << ", mesh name: " << doc.child("mesh").attribute("name").value() << std::endl;
+    }
+
+    {
+    // tag::load_string[]
+        // You can use load to load document from null-terminated strings, for example literals:
+        pugi::xml_parse_result result = doc.load_string("<mesh name='sphere'><bounds>0 0 1 1</bounds></mesh>");
+    // end::load_string[]
+
+        std::cout << "Load result: " << result.description() << ", mesh name: " << doc.child("mesh").attribute("name").value() << std::endl;
+    }
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/load_options.cpp

@@ -0,0 +1,30 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+
+// tag::code[]
+    const char* source = "<!--comment--><node>&lt;</node>";
+
+    // Parsing with default options; note that comment node is not added to the tree, and entity reference &lt; is expanded
+    doc.load_string(source);
+    std::cout << "First node value: [" << doc.first_child().value() << "], node child value: [" << doc.child_value("node") << "]\n";
+
+    // Parsing with additional parse_comments option; comment node is now added to the tree
+    doc.load_string(source, pugi::parse_default | pugi::parse_comments);
+    std::cout << "First node value: [" << doc.first_child().value() << "], node child value: [" << doc.child_value("node") << "]\n";
+
+    // Parsing with additional parse_comments option and without the (default) parse_escapes option; &lt; is not expanded
+    doc.load_string(source, (pugi::parse_default | pugi::parse_comments) & ~pugi::parse_escapes);
+    std::cout << "First node value: [" << doc.first_child().value() << "], node child value: [" << doc.child_value("node") << "]\n";
+
+    // Parsing with minimal option mask; comment node is not added to the tree, and &lt; is not expanded
+    doc.load_string(source, pugi::parse_minimal);
+    std::cout << "First node value: [" << doc.first_child().value() << "], node child value: [" << doc.child_value("node") << "]\n";
+// end::code[]
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/load_stream.cpp

@@ -0,0 +1,97 @@
+#include "pugixml.hpp"
+
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+
+void print_doc(const char* message, const pugi::xml_document& doc, const pugi::xml_parse_result& result)
+{
+    std::cout
+        << message
+        << "\t: load result '" << result.description() << "'"
+        << ", first character of root name: U+" << std::hex << std::uppercase << std::setw(4) << std::setfill('0') << pugi::as_wide(doc.first_child().name())[0]
+        << ", year: " << doc.first_child().first_child().first_child().child_value()
+        << std::endl;
+}
+
+bool try_imbue(std::wistream& stream, const char* name)
+{
+    try
+    {
+        stream.imbue(std::locale(name));
+
+        return true;
+    }
+    catch (const std::exception&)
+    {
+        return false;
+    }
+}
+
+int main()
+{
+    pugi::xml_document doc;
+
+    {
+    // tag::code[]
+        std::ifstream stream("weekly-utf-8.xml");
+        pugi::xml_parse_result result = doc.load(stream);
+    // end::code[]
+
+        // first character of root name: U+9031, year: 1997
+        print_doc("UTF8 file from narrow stream", doc, result);
+    }
+
+    {
+        std::ifstream stream("weekly-utf-16.xml");
+        pugi::xml_parse_result result = doc.load(stream);
+
+        // first character of root name: U+9031, year: 1997
+        print_doc("UTF16 file from narrow stream", doc, result);
+    }
+
+    {
+        // Since wide streams are treated as UTF-16/32 ones, you can't load the UTF-8 file from a wide stream
+        // directly if you have localized characters; you'll have to provide a UTF8 locale (there is no
+        // standard one; you can use utf8_codecvt_facet from Boost or codecvt_utf8 from C++0x)
+        std::wifstream stream("weekly-utf-8.xml");
+
+        if (try_imbue(stream, "en_US.UTF-8")) // try Linux encoding
+        {
+            pugi::xml_parse_result result = doc.load(stream);
+
+            // first character of root name: U+00E9, year: 1997
+            print_doc("UTF8 file from wide stream", doc, result);
+        }
+        else
+        {
+            std::cout << "UTF-8 locale is not available\n";
+        }
+    }
+
+    {
+        // Since wide streams are treated as UTF-16/32 ones, you can't load the UTF-16 file from a wide stream without
+        // using custom codecvt; you can use codecvt_utf16 from C++0x
+    }
+
+    {
+        // Since encoding names are non-standard, you can't load the Shift-JIS (or any other non-ASCII) file
+        // from a wide stream portably
+        std::wifstream stream("weekly-shift_jis.xml");
+
+        if (try_imbue(stream, ".932") || // try Microsoft encoding
+            try_imbue(stream, "ja_JP.SJIS")) // try Linux encoding; run "localedef -i ja_JP -c -f SHIFT_JIS /usr/lib/locale/ja_JP.SJIS" to get it
+        {
+            pugi::xml_parse_result result = doc.load(stream);
+
+            // first character of root name: U+9031, year: 1997
+            print_doc("Shift-JIS file from wide stream", doc, result);
+        }
+        else
+        {
+            std::cout << "Shift-JIS locale is not available\n";
+        }
+    }
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/modify_add.cpp

@@ -0,0 +1,29 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+
+    // tag::code[]
+    // add node with some name
+    pugi::xml_node node = doc.append_child("node");
+
+    // add description node with text child
+    pugi::xml_node descr = node.append_child("description");
+    descr.append_child(pugi::node_pcdata).set_value("Simple node");
+
+    // add param node before the description
+    pugi::xml_node param = node.insert_child_before("param", descr);
+
+    // add attributes to param node
+    param.append_attribute("name") = "version";
+    param.append_attribute("value") = 1.1;
+    param.insert_attribute_after("type", param.attribute("name")) = "float";
+    // end::code[]
+
+    doc.print(std::cout);
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/modify_base.cpp

@@ -0,0 +1,43 @@
+#include "pugixml.hpp"
+
+#include <string.h>
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load_string("<node id='123'>text</node><!-- comment -->", pugi::parse_default | pugi::parse_comments)) return -1;
+
+    // tag::node[]
+    pugi::xml_node node = doc.child("node");
+
+    // change node name
+    std::cout << node.set_name("notnode");
+    std::cout << ", new node name: " << node.name() << std::endl;
+
+    // change comment text
+    std::cout << doc.last_child().set_value("useless comment");
+    std::cout << ", new comment text: " << doc.last_child().value() << std::endl;
+
+    // we can't change value of the element or name of the comment
+    std::cout << node.set_value("1") << ", " << doc.last_child().set_name("2") << std::endl;
+    // end::node[]
+
+    // tag::attr[]
+    pugi::xml_attribute attr = node.attribute("id");
+
+    // change attribute name/value
+    std::cout << attr.set_name("key") << ", " << attr.set_value("345");
+    std::cout << ", new attribute: " << attr.name() << "=" << attr.value() << std::endl;
+
+    // we can use numbers or booleans
+    attr.set_value(1.234);
+    std::cout << "new attribute value: " << attr.value() << std::endl;
+
+    // we can also use assignment operators for more concise code
+    attr = true;
+    std::cout << "final attribute value: " << attr.value() << std::endl;
+    // end::attr[]
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/modify_remove.cpp

@@ -0,0 +1,27 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    pugi::xml_document doc;
+    if (!doc.load_string("<node><description>Simple node</description><param name='id' value='123'/></node>")) return -1;
+
+    // tag::code[]
+    // remove description node with the whole subtree
+    pugi::xml_node node = doc.child("node");
+    node.remove_child("description");
+
+    // remove value attribute
+    pugi::xml_node param = node.child("param");
+    param.remove_attribute("value");
+
+    // we can also remove nodes/attributes by handles
+    pugi::xml_attribute id = param.attribute("name");
+    param.remove_attribute(id);
+    // end::code[]
+
+    doc.print(std::cout);
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/save_custom_writer.cpp

@@ -0,0 +1,116 @@
+#include "pugixml.hpp"
+
+#include <string>
+#include <iostream>
+#include <cstring>
+
+// tag::code[]
+struct xml_string_writer: pugi::xml_writer
+{
+    std::string result;
+
+    virtual void write(const void* data, size_t size)
+    {
+        result.append(static_cast<const char*>(data), size);
+    }
+};
+// end::code[]
+
+struct xml_memory_writer: pugi::xml_writer
+{
+    char* buffer;
+    size_t capacity;
+
+    size_t result;
+
+    xml_memory_writer(): buffer(0), capacity(0), result(0)
+    {
+    }
+
+    xml_memory_writer(char* buffer, size_t capacity): buffer(buffer), capacity(capacity), result(0)
+    {
+    }
+
+    size_t written_size() const
+    {
+        return result < capacity ? result : capacity;
+    }
+
+    virtual void write(const void* data, size_t size)
+    {
+        if (result < capacity)
+        {
+            size_t chunk = (capacity - result < size) ? capacity - result : size;
+
+            memcpy(buffer + result, data, chunk);
+        }
+
+        result += size;
+    }
+};
+
+std::string node_to_string(pugi::xml_node node)
+{
+    xml_string_writer writer;
+    node.print(writer);
+
+    return writer.result;
+}
+
+char* node_to_buffer(pugi::xml_node node, char* buffer, size_t size)
+{
+    if (size == 0) return buffer;
+
+    // leave one character for null terminator
+    xml_memory_writer writer(buffer, size - 1);
+    node.print(writer);
+
+    // null terminate
+    buffer[writer.written_size()] = 0;
+
+    return buffer;
+}
+
+char* node_to_buffer_heap(pugi::xml_node node)
+{
+    // first pass: get required memory size
+    xml_memory_writer counter;
+    node.print(counter);
+
+    // allocate necessary size (+1 for null termination)
+    char* buffer = new char[counter.result + 1];
+
+    // second pass: actual printing
+    xml_memory_writer writer(buffer, counter.result);
+    node.print(writer);
+
+    // null terminate
+    buffer[writer.written_size()] = 0;
+
+    return buffer;
+}
+
+int main()
+{
+    // get a test document
+    pugi::xml_document doc;
+    doc.load_string("<foo bar='baz'>hey</foo>");
+
+    // get contents as std::string (single pass)
+    std::cout << "contents: [" << node_to_string(doc) << "]\n";
+
+    // get contents into fixed-size buffer (single pass)
+    char large_buf[128];
+    std::cout << "contents: [" << node_to_buffer(doc, large_buf, sizeof(large_buf)) << "]\n";
+
+    // get contents into fixed-size buffer (single pass, shows truncating behavior)
+    char small_buf[22];
+    std::cout << "contents: [" << node_to_buffer(doc, small_buf, sizeof(small_buf)) << "]\n";
+
+    // get contents into heap-allocated buffer (two passes)
+    char* heap_buf = node_to_buffer_heap(doc);
+    std::cout << "contents: [" << heap_buf << "]\n";
+    delete[] heap_buf;
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/save_declaration.cpp

@@ -0,0 +1,27 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    // tag::code[]
+    // get a test document
+    pugi::xml_document doc;
+    doc.load_string("<foo bar='baz'><call>hey</call></foo>");
+
+    // add a custom declaration node
+    pugi::xml_node decl = doc.prepend_child(pugi::node_declaration);
+    decl.append_attribute("version") = "1.0";
+    decl.append_attribute("encoding") = "UTF-8";
+    decl.append_attribute("standalone") = "no";
+
+    // <?xml version="1.0" encoding="UTF-8" standalone="no"?>
+    // <foo bar="baz">
+    //         <call>hey</call>
+    // </foo>
+    doc.save(std::cout);
+    std::cout << std::endl;
+    // end::code[]
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/save_file.cpp

@@ -0,0 +1,17 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    // get a test document
+    pugi::xml_document doc;
+    doc.load_string("<foo bar='baz'>hey</foo>");
+
+    // tag::code[]
+    // save document to file
+    std::cout << "Saving result: " << doc.save_file("save_file_output.xml") << std::endl;
+    // end::code[]
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/save_options.cpp

@@ -0,0 +1,48 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    // tag::code[]
+    // get a test document
+    pugi::xml_document doc;
+    doc.load_string("<foo bar='baz'><call>hey</call></foo>");
+
+    // default options; prints
+    // <?xml version="1.0"?>
+    // <foo bar="baz">
+    //         <call>hey</call>
+    // </foo>
+    doc.save(std::cout);
+    std::cout << std::endl;
+
+    // default options with custom indentation string; prints
+    // <?xml version="1.0"?>
+    // <foo bar="baz">
+    // --<call>hey</call>
+    // </foo>
+    doc.save(std::cout, "--");
+    std::cout << std::endl;
+
+    // default options without indentation; prints
+    // <?xml version="1.0"?>
+    // <foo bar="baz">
+    // <call>hey</call>
+    // </foo>
+    doc.save(std::cout, "\t", pugi::format_default & ~pugi::format_indent); // can also pass "" instead of indentation string for the same effect
+    std::cout << std::endl;
+
+    // raw output; prints
+    // <?xml version="1.0"?><foo bar="baz"><call>hey</call></foo>
+    doc.save(std::cout, "\t", pugi::format_raw);
+    std::cout << std::endl << std::endl;
+
+    // raw output without declaration; prints
+    // <foo bar="baz"><call>hey</call></foo>
+    doc.save(std::cout, "\t", pugi::format_raw | pugi::format_no_declaration);
+    std::cout << std::endl;
+    // end::code[]
+}
+
+// vim:et

package/thirdparty/pugixml/docs/samples/save_stream.cpp

@@ -0,0 +1,18 @@
+#include "pugixml.hpp"
+
+#include <iostream>
+
+int main()
+{
+    // get a test document
+    pugi::xml_document doc;
+    doc.load_string("<foo bar='baz'><call>hey</call></foo>");
+
+    // tag::code[]
+    // save document to standard output
+    std::cout << "Document:\n";
+    doc.save(std::cout);
+    // end::code[]
+}
+
+// vim:et