From 4e74b13e7a8f75be30e1fde54f041b5cd7640aab Mon Sep 17 00:00:00 2001
From: Reinhard Klambauer <reinhard.klambauer@tugraz.at>
Date: Fri, 22 Nov 2013 14:01:58 +0100
Subject: [PATCH 01/14] Added a method to reset the memory buffer of the
 DynArray class.

The the allocated memory will not be touched so the capacity keeps its current level.
---
 tinyxml2.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tinyxml2.h b/tinyxml2.h
index ca3d90e..26179f9 100755
--- a/tinyxml2.h
+++ b/tinyxml2.h
@@ -216,6 +216,10 @@ public:
         }
     }
 
+    void Reset() {
+        _size = 0;
+    }
+
     void Push( T t ) {
         EnsureCapacity( _size+1 );
         _mem[_size++] = t;

From 3bc3d4e24c35a4c5431be9c8d7610a1e5230bdd0 Mon Sep 17 00:00:00 2001
From: Reinhard Klambauer <reinhard.klambauer@tugraz.at>
Date: Fri, 22 Nov 2013 14:05:21 +0100
Subject: [PATCH 02/14] Added a method to reset the memory buffer to the
 XMLPrinter class.

This enables to reset the printer memory to start again from the beginning.
---
 tinyxml2.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tinyxml2.h b/tinyxml2.h
index 26179f9..edfae82 100755
--- a/tinyxml2.h
+++ b/tinyxml2.h
@@ -1966,6 +1966,14 @@ public:
     int CStrSize() const {
         return _buffer.Size();
     }
+    /**
+    	If in print to memory mode, reset the buffer to the
+    	beginning.
+    */
+    void ResetBuffer() {
+        _buffer.Reset();
+        _buffer.Push(0);
+    }
 
 protected:
     void SealElement();

From ce0510ba2db899c1e4157b6a35dd70710de6bfda Mon Sep 17 00:00:00 2001
From: Lee Thomason <leethomason@gmail.com>
Date: Tue, 26 Nov 2013 21:29:37 -0800
Subject: [PATCH 03/14] rename Reset to Clear to be consistent with XMLDocument

---
 tinyxml2.h | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tinyxml2.h b/tinyxml2.h
index edfae82..fa4eeb5 100755
--- a/tinyxml2.h
+++ b/tinyxml2.h
@@ -216,7 +216,7 @@ public:
         }
     }
 
-    void Reset() {
+    void Clear() {
         _size = 0;
     }
 
@@ -1970,8 +1970,8 @@ public:
     	If in print to memory mode, reset the buffer to the
     	beginning.
     */
-    void ResetBuffer() {
-        _buffer.Reset();
+    void ClearBuffer() {
+        _buffer.Clear();
         _buffer.Push(0);
     }
 

From 61871d60a6e4f4aef8a58d6a1034a0521f545ff1 Mon Sep 17 00:00:00 2001
From: Lee Thomason <leethomason@gmail.com>
Date: Thu, 5 Dec 2013 11:44:38 -0800
Subject: [PATCH 04/14] Fix up the readme, add attribution for the logo.

---
 readme.md | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/readme.md b/readme.md
index 7644f41..8ecd536 100644
--- a/readme.md
+++ b/readme.md
@@ -51,11 +51,10 @@ What it doesn't do.
 
 TinyXML-2 doesn't parse or use DTDs (Document Type Definitions) or XSLs
 (eXtensible Stylesheet Language.) There are other parsers out there 
-that are much more fully
-featured. But they are also much bigger, take longer to set up in
-your project, have a higher learning curve, and often have a more
-restrictive license. If you are working with browsers or have more
-complete XML needs, TinyXML-2 is not the parser for you.
+that are much more fully featured. But they are also much bigger, 
+take longer to set up in your project, have a higher learning curve, 
+and often have a more restrictive license. If you are working with 
+browsers or have more complete XML needs, TinyXML-2 is not the parser for you.
 
 TinyXML-1 vs. TinyXML-2
 -----------------------
@@ -309,8 +308,9 @@ in shaping what is a very successful library. Extra thanks to Yves
 Berquin and Andrew Ellerton who were key contributors.
 
 TinyXML-2 grew from that effort. Lee Thomason is the original author
-of TinyXML-2 (and TinyXML-1) but hopefully TinyXML-2 will be improved
+of TinyXML-2 (and TinyXML-1) but TinyXML-2 has been and is being improved
 by many contributors.
 
-Thanks to John Mackay for the TinyXML-2 logo.
+Thanks to John Mackay at http://john.mackay.rosalilastudio.com for the TinyXML-2 logo!
+
 

From 3dacebf8eee7f1abed5379e8e4779c5fd7ab9e1d Mon Sep 17 00:00:00 2001
From: Leonid Onokhov <sopvop@gmail.com>
Date: Thu, 12 Dec 2013 15:07:34 +0300
Subject: [PATCH 05/14] add TINYXML2_EXPORT define when building shared lib

otherwise it exports no symbols and msvc does not create import .lib
---
 CMakeLists.txt | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b58f9eb..aa2d860 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -53,6 +53,7 @@ if(BUILD_STATIC_LIBS)
 endif(BUILD_STATIC_LIBS)
 add_library(tinyxml2 SHARED tinyxml2.cpp tinyxml2.h)
 set_target_properties(tinyxml2 PROPERTIES
+        COMPILE_DEFINITIONS "TINYXML2_EXPORT"
 	VERSION "${GENERIC_LIB_VERSION}"
 	SOVERSION "${GENERIC_LIB_SOVERSION}")
 

From ba4b328b3da8ad6d46aa1e78e5facf35b65b13e3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Daniel=20Marjam=C3=A4ki?= <daniel.marjamaki@gmail.com>
Date: Fri, 10 Jan 2014 21:37:27 +0100
Subject: [PATCH 06/14] Fixed issue 147 (XMLDocument::LoadFile() may crash on
 non-regular file)

---
 tinyxml2.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/tinyxml2.cpp b/tinyxml2.cpp
index 7e4ff40..4574fb3 100755
--- a/tinyxml2.cpp
+++ b/tinyxml2.cpp
@@ -1639,6 +1639,13 @@ XMLError XMLDocument::LoadFile( FILE* fp )
 {
     Clear();
 
+    fseek( fp, 0, SEEK_SET );
+    fgetc( fp );
+    if ( ferror( fp ) != 0 ) {
+        SetError( XML_ERROR_FILE_READ_ERROR, 0, 0 );
+        return _errorID;
+    }
+
     fseek( fp, 0, SEEK_END );
     size_t size = ftell( fp );
     fseek( fp, 0, SEEK_SET );

From c3708ccf0876d78e7ba96b69a90f3bfabcea85df Mon Sep 17 00:00:00 2001
From: Lee Thomason <leethomason@gmail.com>
Date: Tue, 14 Jan 2014 12:30:03 -0800
Subject: [PATCH 07/14] implement a fix to floating point precision as proposed
 by schuellc.

---
 CMakeLists.txt |  4 +--
 dox            |  2 +-
 tinyxml2.cpp   | 16 ++++-----
 tinyxml2.h     | 11 ++++--
 xmltest.cpp    | 90 ++++++++++++++++++++++++++++++++++----------------
 5 files changed, 80 insertions(+), 43 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index b58f9eb..f0ae3dc 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,8 +10,8 @@ include(GNUInstallDirs)
 ################################
 # set lib version here
 
-set(GENERIC_LIB_VERSION "1.0.12")
-set(GENERIC_LIB_SOVERSION "1")
+set(GENERIC_LIB_VERSION "1.0.13")
+set(GENERIC_LIB_SOVERSION "1")
 
 
 ################################
diff --git a/dox b/dox
index 7ab99ff..2413b2e 100755
--- a/dox
+++ b/dox
@@ -32,7 +32,7 @@ PROJECT_NAME           = "TinyXML-2"
 # This could be handy for archiving the generated documentation or
 # if some version control system is used.
 
-PROJECT_NUMBER = 1.0.12
+PROJECT_NUMBER = 1.0.13
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer
diff --git a/tinyxml2.cpp b/tinyxml2.cpp
index 7e4ff40..50022f4 100755
--- a/tinyxml2.cpp
+++ b/tinyxml2.cpp
@@ -422,16 +422,19 @@ void XMLUtil::ToStr( bool v, char* buffer, int bufferSize )
     TIXML_SNPRINTF( buffer, bufferSize, "%d", v ? 1 : 0 );
 }
 
-
+/*
+	ToStr() of a number is a very tricky topic.
+	https://github.com/leethomason/tinyxml2/issues/106
+*/
 void XMLUtil::ToStr( float v, char* buffer, int bufferSize )
 {
-    TIXML_SNPRINTF( buffer, bufferSize, "%f", v );
+    TIXML_SNPRINTF( buffer, bufferSize, "%.8g", v );
 }
 
 
 void XMLUtil::ToStr( double v, char* buffer, int bufferSize )
 {
-    TIXML_SNPRINTF( buffer, bufferSize, "%f", v );
+    TIXML_SNPRINTF( buffer, bufferSize, "%.17g", v );
 }
 
 
@@ -497,12 +500,7 @@ char* XMLDocument::Identify( char* p, XMLNode** node )
     }
 
     // What is this thing?
-    // - Elements start with a letter or underscore, but xml is reserved.
-    // - Comments: <!--
-    // - Declaration: <?
-    // - Everything else is unknown to tinyxml.
-    //
-
+	// These strings define the matching patters:
     static const char* xmlHeader		= { "<?" };
     static const char* commentHeader	= { "<!--" };
     static const char* dtdHeader		= { "<!" };
diff --git a/tinyxml2.h b/tinyxml2.h
index fa4eeb5..086c282 100755
--- a/tinyxml2.h
+++ b/tinyxml2.h
@@ -116,9 +116,9 @@ inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
 #define TIXML_SSCANF   sscanf
 #endif
 
-static const int TIXML2_MAJOR_VERSION = 1;
-static const int TIXML2_MINOR_VERSION = 0;
-static const int TIXML2_PATCH_VERSION = 12;
+static const int TIXML2_MAJOR_VERSION = 1;
+static const int TIXML2_MINOR_VERSION = 0;
+static const int TIXML2_PATCH_VERSION = 13;
 
 namespace tinyxml2
 {
@@ -1321,6 +1321,11 @@ public:
         XMLAttribute* a = FindOrCreateAttribute( name );
         a->SetAttribute( value );
     }
+    /// Sets the named attribute to value.
+    void SetAttribute( const char* name, float value )		{
+        XMLAttribute* a = FindOrCreateAttribute( name );
+        a->SetAttribute( value );
+    }
 
     /**
     	Delete an attribute.
diff --git a/xmltest.cpp b/xmltest.cpp
index 533bcba..2c1fece 100644
--- a/xmltest.cpp
+++ b/xmltest.cpp
@@ -1139,18 +1139,6 @@ int main( int argc, const char ** argv )
 		XMLTest( "Whitespace  all space", true, 0 == doc.FirstChildElement()->FirstChild() );
 	}
 
-#if 0		// the question being explored is what kind of print to use: 
-			// https://github.com/leethomason/tinyxml2/issues/63
-	{
-		const char* xml = "<element attrA='123456789.123456789' attrB='1.001e9'/>";
-		XMLDocument doc;
-		doc.Parse( xml );
-		doc.FirstChildElement()->SetAttribute( "attrA", 123456789.123456789 );
-		doc.FirstChildElement()->SetAttribute( "attrB", 1.001e9 );
-		doc.Print();
-	}
-#endif
-
 	{
 		// An assert should not fire.
 		const char* xml = "<element/>";
@@ -1240,39 +1228,85 @@ int main( int argc, const char ** argv )
 			"</root>";
 
 		XMLDocument doc;
-		doc.Parse( xml );
+		doc.Parse(xml);
 		XMLElement* subtree = doc.RootElement()->FirstChildElement("one")->FirstChildElement("subtree");
 		XMLElement* two = doc.RootElement()->FirstChildElement("two");
 		two->InsertFirstChild(subtree);
-		XMLPrinter printer1( 0, true );
-		doc.Accept( &printer1 );
-		XMLTest( "Move node from within <one> to <two>", xmlInsideTwo, printer1.CStr());
+		XMLPrinter printer1(0, true);
+		doc.Accept(&printer1);
+		XMLTest("Move node from within <one> to <two>", xmlInsideTwo, printer1.CStr());
 
-		doc.Parse( xml );
+		doc.Parse(xml);
 		subtree = doc.RootElement()->FirstChildElement("one")->FirstChildElement("subtree");
 		two = doc.RootElement()->FirstChildElement("two");
 		doc.RootElement()->InsertAfterChild(two, subtree);
-		XMLPrinter printer2( 0, true );
-		doc.Accept( &printer2 );
-		XMLTest( "Move node from within <one> after <two>", xmlAfterTwo, printer2.CStr(), false );
+		XMLPrinter printer2(0, true);
+		doc.Accept(&printer2);
+		XMLTest("Move node from within <one> after <two>", xmlAfterTwo, printer2.CStr(), false);
 
-		doc.Parse( xml );
+		doc.Parse(xml);
 		XMLNode* one = doc.RootElement()->FirstChildElement("one");
 		subtree = one->FirstChildElement("subtree");
 		doc.RootElement()->InsertAfterChild(one, subtree);
-		XMLPrinter printer3( 0, true );
-		doc.Accept( &printer3 );
-		XMLTest( "Move node from within <one> after <one>", xmlAfterOne, printer3.CStr(), false );
+		XMLPrinter printer3(0, true);
+		doc.Accept(&printer3);
+		XMLTest("Move node from within <one> after <one>", xmlAfterOne, printer3.CStr(), false);
 
-		doc.Parse( xml );
+		doc.Parse(xml);
 		subtree = doc.RootElement()->FirstChildElement("one")->FirstChildElement("subtree");
 		two = doc.RootElement()->FirstChildElement("two");
 		doc.RootElement()->InsertEndChild(subtree);
-		XMLPrinter printer4( 0, true );
-		doc.Accept( &printer4 );
-		XMLTest( "Move node from within <one> after <two>", xmlAfterTwo, printer4.CStr(), false );
+		XMLPrinter printer4(0, true);
+		doc.Accept(&printer4);
+		XMLTest("Move node from within <one> after <two>", xmlAfterTwo, printer4.CStr(), false);
 	}
 
+	{
+		const char* xml = "<svg width = \"128\" height = \"128\">"
+			"	<text> </text>"
+			"</svg>";
+		XMLDocument doc;
+		doc.Parse(xml);
+		doc.Print();
+	}
+
+#if 1
+		// the question being explored is what kind of print to use: 
+		// https://github.com/leethomason/tinyxml2/issues/63
+	{
+		//const char* xml = "<element attrA='123456789.123456789' attrB='1.001e9' attrC='1.0e-10' attrD='1001000000.000000' attrE='0.1234567890123456789'/>";
+		const char* xml = "<element/>";
+		XMLDocument doc;
+		doc.Parse( xml );
+		doc.FirstChildElement()->SetAttribute( "attrA-f64", 123456789.123456789 );
+		doc.FirstChildElement()->SetAttribute( "attrB-f64", 1.001e9 );
+		doc.FirstChildElement()->SetAttribute( "attrC-f64", 1.0e9 );
+		doc.FirstChildElement()->SetAttribute( "attrC-f64", 1.0e20 );
+		doc.FirstChildElement()->SetAttribute( "attrD-f64", 1.0e-10 );
+		doc.FirstChildElement()->SetAttribute( "attrD-f64", 0.123456789 );
+
+		doc.FirstChildElement()->SetAttribute( "attrA-f32", 123456789.123456789f );
+		doc.FirstChildElement()->SetAttribute( "attrB-f32", 1.001e9f );
+		doc.FirstChildElement()->SetAttribute( "attrC-f32", 1.0e9f );
+		doc.FirstChildElement()->SetAttribute( "attrC-f32", 1.0e20f );
+		doc.FirstChildElement()->SetAttribute( "attrD-f32", 1.0e-10f );
+		doc.FirstChildElement()->SetAttribute( "attrD-f32", 0.123456789f );
+
+		doc.Print();
+
+		/* The result of this test is platform, compiler, and library version dependent. :("
+		XMLPrinter printer;
+		doc.Print( &printer );
+		XMLTest( "Float and double formatting.", 
+			"<element attrA-f64=\"123456789.12345679\" attrB-f64=\"1001000000\" attrC-f64=\"1e+20\" attrD-f64=\"0.123456789\" attrA-f32=\"1.2345679e+08\" attrB-f32=\"1.001e+09\" attrC-f32=\"1e+20\" attrD-f32=\"0.12345679\"/>\n",
+			printer.CStr(), 
+			true );
+		*/
+	}
+#endif
+
+
+
 	// ----------- Performance tracking --------------
 	{
 #if defined( _MSC_VER )

From 8fe342a872c1f9b3980bee950e4728f4a8ae7f64 Mon Sep 17 00:00:00 2001
From: Uli Kusterer <ulivc@zathras.de>
Date: Tue, 21 Jan 2014 01:12:47 +0100
Subject: [PATCH 08/14] Add SetText() as analog to GetText().

---
 tinyxml2.cpp | 10 ++++++++++
 tinyxml2.h   |  8 +++++---
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/tinyxml2.cpp b/tinyxml2.cpp
index 5880557..95075a5 100755
--- a/tinyxml2.cpp
+++ b/tinyxml2.cpp
@@ -1260,6 +1260,16 @@ const char* XMLElement::GetText() const
 }
 
 
+void	XMLElement::SetText( const char* inText )
+{
+	if ( FirstChild() )
+		FirstChild()->SetValue( inText );
+	else {
+		XMLText*	theText = GetDocument()->NewText( inText );
+		InsertFirstChild( theText );
+	}
+}
+
 XMLError XMLElement::QueryIntText( int* ival ) const
 {
     if ( FirstChild() && FirstChild()->ToText() ) {
diff --git a/tinyxml2.h b/tinyxml2.h
index 086c282..3ae1c32 100755
--- a/tinyxml2.h
+++ b/tinyxml2.h
@@ -116,9 +116,9 @@ inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
 #define TIXML_SSCANF   sscanf
 #endif
 
-static const int TIXML2_MAJOR_VERSION = 1;
-static const int TIXML2_MINOR_VERSION = 0;
-static const int TIXML2_PATCH_VERSION = 13;
+static const int TIXML2_MAJOR_VERSION = 1;
+static const int TIXML2_MINOR_VERSION = 0;
+static const int TIXML2_PATCH_VERSION = 13;
 
 namespace tinyxml2
 {
@@ -1369,6 +1369,8 @@ public:
     */
     const char* GetText() const;
 
+	void	SetText( const char* inText );
+
     /**
     	Convenience method to query the value of a child text node. This is probably best
     	shown by example. Given you have a document is this form:

From 85fff5e50a6b6c1b9cb668fb795ee99ce7590193 Mon Sep 17 00:00:00 2001
From: Uli Kusterer <ulivc@zathras.de>
Date: Tue, 21 Jan 2014 01:35:30 +0100
Subject: [PATCH 09/14] Add comment for SetText().

---
 tinyxml2.h | 34 ++++++++++++++++++++++++++++++++++
 1 file changed, 34 insertions(+)

diff --git a/tinyxml2.h b/tinyxml2.h
index 3ae1c32..2330ab9 100755
--- a/tinyxml2.h
+++ b/tinyxml2.h
@@ -1369,6 +1369,40 @@ public:
     */
     const char* GetText() const;
 
+    /** Convenience function for easy access to the text inside an element. Although easy
+    	and concise, SetText() is limited compared to creating an XMLText child
+    	and mutating it directly.
+
+    	If the first child of 'this' is a XMLText, SetText() sets its value to
+		the given string, otherwise it will create a first child that is an XMLText.
+
+    	This is a convenient method for setting the text of simple contained text:
+    	@verbatim
+    	<foo>This is text</foo>
+    		fooElement->SetText( "Hullaballoo!" );
+     	<foo>Hullaballoo!</foo>
+		@endverbatim
+
+    	Note that this function can be misleading. If the element foo was created from
+    	this XML:
+    	@verbatim
+    		<foo><b>This is text</b></foo>
+    	@endverbatim
+
+    	then it will not change "This is text", but rather prefix it with a text element:
+    	@verbatim
+    		<foo>Hullaballoo!<b>This is text</b></foo>
+    	@endverbatim
+		
+		For this XML:
+    	@verbatim
+    		<foo />
+    	@endverbatim
+    	SetText() will generate
+    	@verbatim
+    		<foo>Hullaballoo!</foo>
+    	@endverbatim
+    */
 	void	SetText( const char* inText );
 
     /**

From 869bb599c14199905d35819796fb686b0b36e958 Mon Sep 17 00:00:00 2001
From: Uli Kusterer <ulivc@zathras.de>
Date: Tue, 21 Jan 2014 01:36:16 +0100
Subject: [PATCH 10/14] Make SetText() behave like the docs say.

---
 tinyxml2.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tinyxml2.cpp b/tinyxml2.cpp
index 95075a5..0338beb 100755
--- a/tinyxml2.cpp
+++ b/tinyxml2.cpp
@@ -1262,7 +1262,7 @@ const char* XMLElement::GetText() const
 
 void	XMLElement::SetText( const char* inText )
 {
-	if ( FirstChild() )
+	if ( FirstChild() && FirstChild()->ToText() )
 		FirstChild()->SetValue( inText );
 	else {
 		XMLText*	theText = GetDocument()->NewText( inText );

From 321072ee0b3ab0b64b1e94c2e2a2e00096892a2f Mon Sep 17 00:00:00 2001
From: Uli Kusterer <ulivc@zathras.de>
Date: Tue, 21 Jan 2014 01:57:38 +0100
Subject: [PATCH 11/14] Add tests for SetText().

---
 xmltest.cpp | 32 ++++++++++++++++++++++++++++++++
 1 file changed, 32 insertions(+)

diff --git a/xmltest.cpp b/xmltest.cpp
index 2c1fece..6cde449 100644
--- a/xmltest.cpp
+++ b/xmltest.cpp
@@ -617,6 +617,38 @@ int main( int argc, const char ** argv )
 	}
 
 
+	// --------SetText()-----------
+	{
+		const char* str = "<foo></foo>";
+		XMLDocument doc;
+		doc.Parse( str );
+		XMLElement* element = doc.RootElement();
+
+		element->SetText("He kept turning his head to left and right, but I could not see anything through the darkness.");
+		XMLTest( "SetText() normal use (open/close).", "He kept turning his head to left and right, but I could not see anything through the darkness.", element->GetText() );
+
+		element->SetText("Suddenly, away on our left I saw a faint flickering blue flame.");
+		XMLTest( "SetText() replace.", "Suddenly, away on our left I saw a faint flickering blue flame.", element->GetText() );
+
+		str = "<foo/>";
+		doc.Parse( str );
+		element = doc.RootElement();
+
+		element->SetText("The driver saw it at the same moment.");
+		XMLTest( "SetText() normal use. (self-closing)", "The driver saw it at the same moment.", element->GetText() );
+
+		element->SetText("<b>He at once checked the horses, and, jumping to the ground, disappeared into the darkness.</b>");
+		XMLTest( "SetText() replace with tag-like text.", "<b>He at once checked the horses, and, jumping to the ground, disappeared into the darkness.</b>", element->GetText() );
+
+		str = "<foo><bar>Text in nested element</bar></foo>";
+		doc.Parse( str );
+		element = doc.RootElement();
+		
+		element->SetText("I did not know what to do, the less as the howling of the wolves grew closer.");
+		XMLTest( "SetText() prefix to nested non-text children.", "I did not know what to do, the less as the howling of the wolves grew closer.", element->GetText() );
+	}
+
+
 	// ---------- CDATA ---------------
 	{
 		const char* str =	"<xmlElement>"

From 9c0678a01d5e0ab4b369f9ba6661790e948427bd Mon Sep 17 00:00:00 2001
From: Lee Thomason <leethomason@gmail.com>
Date: Fri, 24 Jan 2014 10:18:27 -0800
Subject: [PATCH 12/14] trim the test cases and review

---
 xmltest.cpp | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/xmltest.cpp b/xmltest.cpp
index 6cde449..8af4e32 100644
--- a/xmltest.cpp
+++ b/xmltest.cpp
@@ -624,28 +624,29 @@ int main( int argc, const char ** argv )
 		doc.Parse( str );
 		XMLElement* element = doc.RootElement();
 
-		element->SetText("He kept turning his head to left and right, but I could not see anything through the darkness.");
-		XMLTest( "SetText() normal use (open/close).", "He kept turning his head to left and right, but I could not see anything through the darkness.", element->GetText() );
+		element->SetText("darkness.");
+		XMLTest( "SetText() normal use (open/close).", "darkness.", element->GetText() );
 
-		element->SetText("Suddenly, away on our left I saw a faint flickering blue flame.");
-		XMLTest( "SetText() replace.", "Suddenly, away on our left I saw a faint flickering blue flame.", element->GetText() );
+		element->SetText("blue flame.");
+		XMLTest( "SetText() replace.", "blue flame.", element->GetText() );
 
 		str = "<foo/>";
 		doc.Parse( str );
 		element = doc.RootElement();
 
-		element->SetText("The driver saw it at the same moment.");
-		XMLTest( "SetText() normal use. (self-closing)", "The driver saw it at the same moment.", element->GetText() );
+		element->SetText("The driver");
+		XMLTest( "SetText() normal use. (self-closing)", "The driver", element->GetText() );
 
-		element->SetText("<b>He at once checked the horses, and, jumping to the ground, disappeared into the darkness.</b>");
-		XMLTest( "SetText() replace with tag-like text.", "<b>He at once checked the horses, and, jumping to the ground, disappeared into the darkness.</b>", element->GetText() );
+		element->SetText("<b>horses</b>");
+		XMLTest( "SetText() replace with tag-like text.", "<b>horses</b>", element->GetText() );
+		//doc.Print();
 
 		str = "<foo><bar>Text in nested element</bar></foo>";
 		doc.Parse( str );
 		element = doc.RootElement();
 		
-		element->SetText("I did not know what to do, the less as the howling of the wolves grew closer.");
-		XMLTest( "SetText() prefix to nested non-text children.", "I did not know what to do, the less as the howling of the wolves grew closer.", element->GetText() );
+		element->SetText("wolves");
+		XMLTest( "SetText() prefix to nested non-text children.", "wolves", element->GetText() );
 	}
 
 

From 5bb2d8079bad8ed2e22659326d8c77fadf4e6e4b Mon Sep 17 00:00:00 2001
From: Lee Thomason <leethomason@gmail.com>
Date: Fri, 24 Jan 2014 10:42:57 -0800
Subject: [PATCH 13/14] add variants of SetText() to support types

---
 CMakeLists.txt |  2 +-
 dox            |  2 +-
 tinyxml2.cpp   | 41 +++++++++++++++++++++++++++++++++++++++++
 tinyxml2.h     | 15 +++++++++++++--
 xmltest.cpp    | 22 ++++++++++++++++++++++
 5 files changed, 78 insertions(+), 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 399c4c2..12cac92 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -10,7 +10,7 @@ include(GNUInstallDirs)
 ################################
 # set lib version here
 
-set(GENERIC_LIB_VERSION "1.0.13")
+set(GENERIC_LIB_VERSION "1.0.14")
 set(GENERIC_LIB_SOVERSION "1")
 
 
diff --git a/dox b/dox
index 2413b2e..10878f4 100755
--- a/dox
+++ b/dox
@@ -32,7 +32,7 @@ PROJECT_NAME           = "TinyXML-2"
 # This could be handy for archiving the generated documentation or
 # if some version control system is used.
 
-PROJECT_NUMBER = 1.0.13
+PROJECT_NUMBER = 1.0.14
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer
diff --git a/tinyxml2.cpp b/tinyxml2.cpp
index 0338beb..cb26e00 100755
--- a/tinyxml2.cpp
+++ b/tinyxml2.cpp
@@ -1270,6 +1270,47 @@ void	XMLElement::SetText( const char* inText )
 	}
 }
 
+
+void XMLElement::SetText( int v ) 
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    SetText( buf );
+}
+
+
+void XMLElement::SetText( unsigned v ) 
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    SetText( buf );
+}
+
+
+void XMLElement::SetText( bool v ) 
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    SetText( buf );
+}
+
+
+void XMLElement::SetText( float v ) 
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    SetText( buf );
+}
+
+
+void XMLElement::SetText( double v ) 
+{
+    char buf[BUF_SIZE];
+    XMLUtil::ToStr( v, buf, BUF_SIZE );
+    SetText( buf );
+}
+
+
 XMLError XMLElement::QueryIntText( int* ival ) const
 {
     if ( FirstChild() && FirstChild()->ToText() ) {
diff --git a/tinyxml2.h b/tinyxml2.h
index 2330ab9..41f1c70 100755
--- a/tinyxml2.h
+++ b/tinyxml2.h
@@ -118,7 +118,7 @@ inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
 
 static const int TIXML2_MAJOR_VERSION = 1;
 static const int TIXML2_MINOR_VERSION = 0;
-static const int TIXML2_PATCH_VERSION = 13;
+static const int TIXML2_PATCH_VERSION = 14;
 
 namespace tinyxml2
 {
@@ -1403,7 +1403,17 @@ public:
     		<foo>Hullaballoo!</foo>
     	@endverbatim
     */
-	void	SetText( const char* inText );
+	void SetText( const char* inText );
+    /// Convenince method for setting text inside and element. See SetText() for important limitations.
+    void SetText( int value );
+    /// Convenince method for setting text inside and element. See SetText() for important limitations.
+    void SetText( unsigned value );  
+    /// Convenince method for setting text inside and element. See SetText() for important limitations.
+    void SetText( bool value );  
+    /// Convenince method for setting text inside and element. See SetText() for important limitations.
+    void SetText( double value );  
+    /// Convenince method for setting text inside and element. See SetText() for important limitations.
+    void SetText( float value );  
 
     /**
     	Convenience method to query the value of a child text node. This is probably best
@@ -1465,6 +1475,7 @@ private:
     //void LinkAttribute( XMLAttribute* attrib );
     char* ParseAttributes( char* p );
 
+    enum { BUF_SIZE = 200 };
     int _closingType;
     // The attribute list is ordered; there is no 'lastAttribute'
     // because the list needs to be scanned for dupes before adding
diff --git a/xmltest.cpp b/xmltest.cpp
index 8af4e32..6fdc162 100644
--- a/xmltest.cpp
+++ b/xmltest.cpp
@@ -647,6 +647,28 @@ int main( int argc, const char ** argv )
 		
 		element->SetText("wolves");
 		XMLTest( "SetText() prefix to nested non-text children.", "wolves", element->GetText() );
+
+		str = "<foo/>";
+		doc.Parse( str );
+		element = doc.RootElement();
+		
+		element->SetText( "str" );
+		XMLTest( "SetText types", "str", element->GetText() );
+
+		element->SetText( 1 );
+		XMLTest( "SetText types", "1", element->GetText() );
+
+		element->SetText( 1U );
+		XMLTest( "SetText types", "1", element->GetText() );
+
+		element->SetText( true );
+		XMLTest( "SetText types", "1", element->GetText() ); // TODO: should be 'true'?
+
+		element->SetText( 1.5f );
+		XMLTest( "SetText types", "1.5", element->GetText() );
+
+		element->SetText( 1.5 );
+		XMLTest( "SetText types", "1.5", element->GetText() );
 	}
 
 

From c18eb233269d081c3f3b539e37eab185b678b026 Mon Sep 17 00:00:00 2001
From: Lee Thomason <leethomason@gmail.com>
Date: Fri, 21 Feb 2014 17:31:17 -0800
Subject: [PATCH 14/14] spelling fixes and make PrintSpace() virtual and
 protected.

---
 tinyxml2.h | 32 +++++++++++++++++++++-----------
 1 file changed, 21 insertions(+), 11 deletions(-)

diff --git a/tinyxml2.h b/tinyxml2.h
index 41f1c70..fc54320 100755
--- a/tinyxml2.h
+++ b/tinyxml2.h
@@ -116,9 +116,15 @@ inline int TIXML_SNPRINTF( char* buffer, size_t size, const char* format, ... )
 #define TIXML_SSCANF   sscanf
 #endif
 
+/* Versioning, past 1.0.14:
+
+	A backwards-incompatible change or API change bumps the major version.
+	An API addition or a backwards-compatible change, bumps the minor version.
+	Simple bug fixes bump the build number.
+*/
 static const int TIXML2_MAJOR_VERSION = 1;
-static const int TIXML2_MINOR_VERSION = 0;
-static const int TIXML2_PATCH_VERSION = 14;
+static const int TIXML2_MINOR_VERSION = 1;
+static const int TIXML2_PATCH_VERSION = 0;
 
 namespace tinyxml2
 {
@@ -1404,15 +1410,15 @@ public:
     	@endverbatim
     */
 	void SetText( const char* inText );
-    /// Convenince method for setting text inside and element. See SetText() for important limitations.
+    /// Convenience method for setting text inside and element. See SetText() for important limitations.
     void SetText( int value );
-    /// Convenince method for setting text inside and element. See SetText() for important limitations.
+    /// Convenience method for setting text inside and element. See SetText() for important limitations.
     void SetText( unsigned value );  
-    /// Convenince method for setting text inside and element. See SetText() for important limitations.
+    /// Convenience method for setting text inside and element. See SetText() for important limitations.
     void SetText( bool value );  
-    /// Convenince method for setting text inside and element. See SetText() for important limitations.
+    /// Convenience method for setting text inside and element. See SetText() for important limitations.
     void SetText( double value );  
-    /// Convenince method for setting text inside and element. See SetText() for important limitations.
+    /// Convenience method for setting text inside and element. See SetText() for important limitations.
     void SetText( float value );  
 
     /**
@@ -2028,21 +2034,25 @@ public:
     }
 
 protected:
-    void SealElement();
+	/** Prints out the space before an element. You may override to change
+	    the space and tabs used. A PrintSpace() override should call Print().
+	*/
+    virtual void PrintSpace( int depth );
+    void Print( const char* format, ... );
+
+	void SealElement();
     bool _elementJustOpened;
     DynArray< const char*, 10 > _stack;
 
 private:
-    void PrintSpace( int depth );
     void PrintString( const char*, bool restrictedEntitySet );	// prints out, after detecting entities.
-    void Print( const char* format, ... );
 
     bool _firstElement;
     FILE* _fp;
     int _depth;
     int _textDepth;
     bool _processEntities;
-    bool _compactMode;
+	bool _compactMode;
 
     enum {
         ENTITY_RANGE = 64,