diff --git a/include/eepp/core/string.hpp b/include/eepp/core/string.hpp
index 4426aba1e..9c3082295 100644
--- a/include/eepp/core/string.hpp
+++ b/include/eepp/core/string.hpp
@@ -58,7 +58,20 @@ class EE_API String {
 	static constexpr Uint32 hash( const Uint8 * str );
 
 	/** @return string hash */
-	static constexpr Uint32 hash( const char * str );
+	static constexpr Uint32 hash( const char * str ) {
+		//! djb2
+		if ( NULL != str ) {
+			Uint32 hash = 5381;
+			Int32 c = 0;
+
+			while ( ( c = *str++ ) )
+				hash = ( ( hash << 5 ) + hash ) + c;
+
+			return hash;
+		}
+
+		return 0;
+	}
 
 	/** @return string hash */
 	static Uint32 hash( const std::string& str );
diff --git a/include/eepp/maps/maphelper.hpp b/include/eepp/maps/maphelper.hpp
index 95de09c6a..530c7ce08 100644
--- a/include/eepp/maps/maphelper.hpp
+++ b/include/eepp/maps/maphelper.hpp
@@ -2,6 +2,7 @@
 #define EE_MAPS_MAPHELPER_HPP
 
 #include <eepp/config.hpp>
+#include <eepp/core/string.hpp>
 
 namespace EE { namespace Maps {
 
@@ -92,14 +93,14 @@ class GObjFlags {
 };
 
 enum EE_GAMEOBJECT_TYPE {
-	GAMEOBJECT_TYPE_BASE			= 2088954976UL,	//String::hash( "Base" )
-	GAMEOBJECT_TYPE_VIRTUAL			= 3708695628UL,	//String::hash( "Virtual" )
-	GAMEOBJECT_TYPE_TEXTUREREGION	= 1772101792UL,	//String::hash( "SubTexture" )
-	GAMEOBJECT_TYPE_TEXTUREREGIONEX	= 1378537981UL,	//String::hash( "SubTextureEx" )
-	GAMEOBJECT_TYPE_SPRITE			= 3517332124UL,	//String::hash( "Sprite" )
-	GAMEOBJECT_TYPE_OBJECT			= 3343895260UL,	//String::hash( "Object" )
-	GAMEOBJECT_TYPE_POLYGON			= 482716845UL,	//String::hash( "Polygon" )
-	GAMEOBJECT_TYPE_POLYLINE		= 3044927249UL	//String::hash( "Polyline" )
+	GAMEOBJECT_TYPE_BASE			= String::hash( "Base" ),
+	GAMEOBJECT_TYPE_VIRTUAL			= String::hash( "Virtual" ),
+	GAMEOBJECT_TYPE_TEXTUREREGION	= String::hash( "SubTexture" ),
+	GAMEOBJECT_TYPE_TEXTUREREGIONEX	= String::hash( "SubTextureEx" ),
+	GAMEOBJECT_TYPE_SPRITE			= String::hash( "Sprite" ),
+	GAMEOBJECT_TYPE_OBJECT			= String::hash( "Object" ),
+	GAMEOBJECT_TYPE_POLYGON			= String::hash( "Polygon" ),
+	GAMEOBJECT_TYPE_POLYLINE		= String::hash( "Polyline" )
 };
 
 enum EE_LAYER_TYPE {
diff --git a/src/eepp/core/string.cpp b/src/eepp/core/string.cpp
index 7f0f94930..b4d60f0fc 100644
--- a/src/eepp/core/string.cpp
+++ b/src/eepp/core/string.cpp
@@ -24,21 +24,6 @@ constexpr Uint32 String::hash( const Uint8 * str ) {
 	return 0;
 }
 
-constexpr Uint32 String::hash( const char * str ) {
-	//! djb2
-	if ( NULL != str ) {
-		Uint32 hash = 5381;
-		Int32 c = 0;
-
-		while ( ( c = *str++ ) )
-			hash = ( ( hash << 5 ) + hash ) + c;
-
-		return hash;
-	}
-
-	return 0;
-}
-
 Uint32 String::hash( const std::string& str ) {
 	return String::hash( str.c_str() );
 }
@@ -271,33 +256,27 @@ std::string String::format( const char * format, ... ) {
 }
 
 String::String()
-{
-}
+{}
 
-String::String(char ansiChar, const std::locale& locale)
-{
+String::String(char ansiChar, const std::locale& locale) {
 	mString += Utf32::decodeAnsi(ansiChar, locale);
 }
 
 #ifndef EE_NO_WIDECHAR
-String::String(wchar_t wideChar)
-{
+String::String(wchar_t wideChar) {
 	mString += Utf32::decodeWide(wideChar);
 }
 #endif
 
-String::String(StringBaseType utf32Char)
-{
+String::String(StringBaseType utf32Char) {
 	mString += utf32Char;
 }
 
 String::String( const char* uf8String ) {
-	if (uf8String)
-	{
+	if (uf8String) {
 		std::size_t length = strlen(uf8String);
 
-		if (length > 0)
-		{
+		if (length > 0) {
 			mString.reserve(length + 1);
 
 			Utf8::toUtf32(uf8String, uf8String + length, std::back_inserter(mString));
@@ -311,64 +290,52 @@ String::String( const std::string& utf8String ) {
 	Utf8::toUtf32( utf8String.begin(), utf8String.end(), std::back_inserter( mString ) );
 }
 
-String::String(const char* ansiString, const std::locale& locale)
-{
-	if (ansiString)
-	{
+String::String(const char* ansiString, const std::locale& locale) {
+	if (ansiString) {
 		std::size_t length = strlen(ansiString);
-		if (length > 0)
-		{
+		if (length > 0) {
 			mString.reserve(length + 1);
 			Utf32::fromAnsi(ansiString, ansiString + length, std::back_inserter(mString), locale);
 		}
 	}
 }
 
-String::String(const std::string& ansiString, const std::locale& locale)
-{
+String::String(const std::string& ansiString, const std::locale& locale) {
 	mString.reserve(ansiString.length() + 1);
 	Utf32::fromAnsi(ansiString.begin(), ansiString.end(), std::back_inserter(mString), locale);
 }
 
 #ifndef EE_NO_WIDECHAR
-String::String(const wchar_t* wideString)
-{
-	if (wideString)
-	{
+String::String(const wchar_t* wideString) {
+	if (wideString) {
 		std::size_t length = std::wcslen(wideString);
-		if (length > 0)
-		{
+		if (length > 0) {
 			mString.reserve(length + 1);
 			Utf32::fromWide(wideString, wideString + length, std::back_inserter(mString));
 		}
 	}
 }
 
-String::String(const std::wstring& wideString)
-{
+String::String(const std::wstring& wideString) {
 	mString.reserve(wideString.length() + 1);
 	Utf32::fromWide(wideString.begin(), wideString.end(), std::back_inserter(mString));
 }
 #endif
 
-String::String(const StringBaseType* utf32String)
-{
+String::String(const StringBaseType* utf32String) {
 	if (utf32String)
 		mString = utf32String;
 }
 
 String::String(const StringType& utf32String) :
 mString(utf32String)
-{
-}
+{}
 
 String::String(const String& str) :
 mString(str.mString)
-{
-}
+{}
 
-String String::fromUtf8( const std::string& utf8String )
-{
+String String::fromUtf8( const std::string& utf8String ) {
 	String::StringType utf32;
 
 	utf32.reserve( utf8String.length() + 1 );
@@ -378,13 +345,11 @@ String String::fromUtf8( const std::string& utf8String )
 	return String( utf32 );
 }
 
-String::operator std::string() const
-{
+String::operator std::string() const {
 	return toAnsiString();
 }
 
-std::string String::toAnsiString(const std::locale& locale) const
-{
+std::string String::toAnsiString(const std::locale& locale) const {
 	// Prepare the output string
 	std::string output;
 	output.reserve(mString.length() + 1);
@@ -396,8 +361,7 @@ std::string String::toAnsiString(const std::locale& locale) const
 }
 
 #ifndef EE_NO_WIDECHAR
-std::wstring String::toWideString() const
-{
+std::wstring String::toWideString() const {
 	// Prepare the output string
 	std::wstring output;
 	output.reserve(mString.length() + 1);
@@ -431,100 +395,82 @@ std::basic_string<Uint16> String::toUtf16() const {
 	return output;
 }
 
-Uint32 String::getHash() const
-{
+Uint32 String::getHash() const {
 	return String::hash( *this );
 }
 
-String& String::operator =(const String& right)
-{
+String& String::operator =(const String& right) {
 	mString = right.mString;
 	return *this;
 }
 
-String& String::operator =( const StringBaseType& right )
-{
+String& String::operator =( const StringBaseType& right ) {
 	mString = right;
 	return *this;
 }
 
-String& String::operator +=(const String& right)
-{
+String& String::operator +=(const String& right) {
 	mString += right.mString;
 	return *this;
 }
 
-String& String::operator +=( const StringBaseType& right )
-{
+String& String::operator +=( const StringBaseType& right ) {
 	mString += right;
 	return *this;
 }
 
 
-String::StringBaseType String::operator [](std::size_t index) const
-{
+String::StringBaseType String::operator [](std::size_t index) const {
 	return mString[index];
 }
 
-String::StringBaseType& String::operator [](std::size_t index)
-{
+String::StringBaseType& String::operator [](std::size_t index) {
 	return mString[index];
 }
 
-String::StringBaseType String::at( std::size_t index ) const
-{
+String::StringBaseType String::at( std::size_t index ) const {
 	return mString.at( index );
 }
 
-void String::push_back( StringBaseType c )
-{
+void String::push_back( StringBaseType c ) {
 	mString.push_back( c );
 }
 
-void String::swap ( String& str )
-{
+void String::swap ( String& str ) {
 	mString.swap( str.mString );
 }
 
-void String::clear()
-{
+void String::clear() {
 	mString.clear();
 }
 
-std::size_t String::size() const
-{
+std::size_t String::size() const {
 	return mString.size();
 }
 
-std::size_t String::length() const
-{
+std::size_t String::length() const {
 	return mString.length();
 }
 
-bool String::empty() const
-{
+bool String::empty() const {
 	return mString.empty();
 }
 
-void String::erase(std::size_t position, std::size_t count)
-{
+void String::erase(std::size_t position, std::size_t count) {
 	mString.erase(position, count);
 }
 
-String& String::insert(std::size_t position, const String& str)
-{
+String& String::insert(std::size_t position, const String& str) {
 	mString.insert(position, str.mString);
 	return *this;
 }
 
-String& String::insert( std::size_t pos1, const String& str, std::size_t pos2, std::size_t n )
-{
+String& String::insert( std::size_t pos1, const String& str, std::size_t pos2, std::size_t n ) {
 	mString.insert( pos1, str.mString, pos2, n );
 	return *this;
 }
 
-String& String::insert ( size_t pos1, const char* s, size_t n )
-{
+String& String::insert ( size_t pos1, const char* s, size_t n ) {
 	String tmp( s );
 
 	mString.insert( pos1, tmp.data(), n );
@@ -532,14 +478,12 @@ String& String::insert ( size_t pos1, const char* s, size_t n )
 	return *this;
 }
 
-String& String::insert ( size_t pos1, size_t n, char c )
-{
+String& String::insert ( size_t pos1, size_t n, char c ) {
 	mString.insert( pos1, n, c );
 	return *this;
 }
 
-String& String::insert ( size_t pos1, const char* s )
-{
+String& String::insert ( size_t pos1, const char* s ) {
 	String tmp( s );
 
 	mString.insert( pos1, tmp.data() );
@@ -547,104 +491,85 @@ String& String::insert ( size_t pos1, const char* s )
 	return *this;
 }
 
-String::Iterator String::insert ( Iterator p, char c )
-{
+String::Iterator String::insert ( Iterator p, char c ) {
 	return mString.insert( p, c );
 }
 
-void String::insert ( Iterator p, size_t n, char c )
-{
+void String::insert ( Iterator p, size_t n, char c ) {
 	mString.insert( p, n, c );
 }
 
-const String::StringBaseType* String::c_str() const
-{
+const String::StringBaseType* String::c_str() const {
 	return mString.c_str();
 }
 
-const String::StringBaseType* String::data() const
-{
+const String::StringBaseType* String::data() const {
 	return mString.data();
 }
 
-String::Iterator String::begin()
-{
+String::Iterator String::begin() {
 	return mString.begin();
 }
 
-String::ConstIterator String::begin() const
-{
+String::ConstIterator String::begin() const {
 	return mString.begin();
 }
 
-String::Iterator String::end()
-{
+String::Iterator String::end() {
 	return mString.end();
 }
 
-String::ConstIterator String::end() const
-{
+String::ConstIterator String::end() const {
 	return mString.end();
 }
 
-String::ReverseIterator String::rbegin()
-{
+String::ReverseIterator String::rbegin() {
 	return mString.rbegin();
 }
 
-String::ConstReverseIterator String::rbegin() const
-{
+String::ConstReverseIterator String::rbegin() const {
 	return mString.rbegin();
 }
 
-String::ReverseIterator String::rend()
-{
+String::ReverseIterator String::rend() {
 	return mString.rend();
 }
 
-String::ConstReverseIterator String::rend() const
-{
+String::ConstReverseIterator String::rend() const {
 	return mString.rend();
 }
 
-void String::resize( std::size_t n, StringBaseType c )
-{
+void String::resize( std::size_t n, StringBaseType c ) {
 	mString.resize( n, c );
 }
 
-void String::resize( std::size_t n )
-{
+void String::resize( std::size_t n ) {
 	mString.resize( n );
 }
 
-std::size_t String::max_size() const
-{
+std::size_t String::max_size() const {
 	return mString.max_size();
 }
 
-void String::reserve( size_t res_arg )
-{
+void String::reserve( size_t res_arg ) {
 	mString.reserve( res_arg );
 }
 
-std::size_t String::capacity() const
-{
+std::size_t String::capacity() const {
 	return mString.capacity();
 }
 
-String& String::assign ( const String& str )
-{
+String& String::assign( const String& str ) {
 	mString.assign( str.mString );
 	return *this;
 }
 
-String& String::assign ( const String& str, size_t pos, size_t n )
-{
+String& String::assign( const String& str, size_t pos, size_t n ) {
 	mString.assign( str.mString, pos, n );
 	return *this;
 }
 
-String& String::assign ( const char* s, size_t n )
+String& String::assign( const char* s, size_t n )
 {
 	String tmp( s );
 
@@ -653,8 +578,7 @@ String& String::assign ( const char* s, size_t n )
 	return *this;
 }
 
-String& String::assign ( const char* s )
-{
+String& String::assign( const char* s ) {
 	String tmp( s );
 
 	mString.assign( tmp.mString );
@@ -662,29 +586,25 @@ String& String::assign ( const char* s )
 	return *this;
 }
 
-String& String::assign ( size_t n, char c )
-{
+String& String::assign( size_t n, char c ) {
 	mString.assign( n, c );
 
 	return *this;
 }
 
-String& String::append ( const String& str )
-{
+String& String::append( const String& str ) {
 	mString.append( str.mString );
 
 	return *this;
 }
 
-String& String::append ( const String& str, size_t pos, size_t n )
-{
+String& String::append( const String& str, size_t pos, size_t n ) {
 	mString.append( str.mString, pos, n );
 
 	return *this;
 }
 
-String& String::append ( const char* s, size_t n )
-{
+String& String::append( const char* s, size_t n ) {
 	String tmp( s );
 
 	mString.append( tmp.mString );
@@ -692,8 +612,7 @@ String& String::append ( const char* s, size_t n )
 	return *this;
 }
 
-String& String::append ( const char* s )
-{
+String& String::append( const char* s ) {
 	String tmp( s );
 
 	mString.append( tmp.mString );
@@ -701,43 +620,37 @@ String& String::append ( const char* s )
 	return *this;
 }
 
-String& String::append ( size_t n, char c )
-{
+String& String::append( size_t n, char c ) {
 	mString.append( n, c );
 
 	return *this;
 }
 
-String& String::append ( std::size_t n, StringBaseType c )
-{
+String& String::append( std::size_t n, StringBaseType c ) {
 	mString.append( n, c );
 
 	return *this;
 }
 
-String& String::replace ( size_t pos1, size_t n1, const String& str )
-{
+String& String::replace( size_t pos1, size_t n1, const String& str ) {
 	mString.replace( pos1, n1, str.mString );
 
 	return *this;
 }
 
-String& String::replace ( Iterator i1, Iterator i2, const String& str )
-{
+String& String::replace( Iterator i1, Iterator i2, const String& str ) {
 	mString.replace( i1, i2, str.mString );
 
 	return *this;
 }
 
-String& String::replace ( size_t pos1, size_t n1, const String& str, size_t pos2, size_t n2 )
-{
+String& String::replace( size_t pos1, size_t n1, const String& str, size_t pos2, size_t n2 ) {
 	mString.replace( pos1, n1, str.mString, pos2, n2 );
 
 	return *this;
 }
 
-String& String::replace ( size_t pos1, size_t n1, const char* s, size_t n2 )
-{
+String& String::replace( size_t pos1, size_t n1, const char* s, size_t n2 ) {
 	String tmp( s );
 
 	mString.replace( pos1, n1, tmp.data(), n2 );
@@ -745,8 +658,7 @@ String& String::replace ( size_t pos1, size_t n1, const char* s, size_t n2 )
 	return *this;
 }
 
-String& String::replace ( Iterator i1, Iterator i2, const char* s, size_t n2 )
-{
+String& String::replace( Iterator i1, Iterator i2, const char* s, size_t n2 ) {
 	String tmp( s );
 
 	mString.replace( i1, i2, tmp.data(), n2 );
@@ -754,8 +666,7 @@ String& String::replace ( Iterator i1, Iterator i2, const char* s, size_t n2 )
 	return *this;
 }
 
-String& String::replace ( size_t pos1, size_t n1,   const char* s )
-{
+String& String::replace( size_t pos1, size_t n1, const char* s ) {
 	String tmp( s );
 
 	mString.replace( pos1, n1, tmp.mString );
@@ -763,8 +674,7 @@ String& String::replace ( size_t pos1, size_t n1,   const char* s )
 	return *this;
 }
 
-String& String::replace ( Iterator i1, Iterator i2, const char* s )
-{
+String& String::replace ( Iterator i1, Iterator i2, const char* s ) {
 	String tmp( s );
 
 	mString.replace( i1, i2, tmp.mString );
@@ -772,212 +682,171 @@ String& String::replace ( Iterator i1, Iterator i2, const char* s )
 	return *this;
 }
 
-String& String::replace ( size_t pos1, size_t n1,   size_t n2, char c )
-{
+String& String::replace( size_t pos1, size_t n1, size_t n2, char c ) {
 	mString.replace( pos1, n1, n2, (StringBaseType)c );
 
 	return *this;
 }
 
-String& String::replace ( Iterator i1, Iterator i2, size_t n2, char c )
-{
+String& String::replace ( Iterator i1, Iterator i2, size_t n2, char c ) {
 	mString.replace( i1, i2, n2, (StringBaseType)c );
 
 	return *this;
 }
 
-std::size_t String::find( const String& str, std::size_t start ) const
-{
+std::size_t String::find( const String& str, std::size_t start ) const {
 	return mString.find( str.mString, start );
 }
 
-std::size_t String::find ( const char* s, std::size_t pos, std::size_t n ) const
-{
+std::size_t String::find( const char* s, std::size_t pos, std::size_t n ) const {
 	return find( String( s ), pos );
 }
 
-std::size_t String::find ( const char* s, std::size_t pos ) const
-{
+std::size_t String::find( const char* s, std::size_t pos ) const {
 	return find( String( s ), pos );
 }
 
-size_t String::find ( char c, std::size_t pos ) const
-{
+size_t String::find ( char c, std::size_t pos ) const {
 	return mString.find( (StringBaseType)c, pos );
 }
 
-std::size_t String::rfind ( const String& str, std::size_t pos ) const
-{
+std::size_t String::rfind( const String& str, std::size_t pos ) const {
 	return mString.rfind( str.mString, pos );
 }
 
-std::size_t String::rfind ( const char* s, std::size_t pos, std::size_t n ) const
-{
+std::size_t String::rfind( const char* s, std::size_t pos, std::size_t n ) const {
 	return rfind( String( s ), pos );
 }
 
-std::size_t String::rfind ( const char* s, std::size_t pos ) const
-{
+std::size_t String::rfind( const char* s, std::size_t pos ) const {
 	return rfind( String( s ), pos );
 }
 
-std::size_t String::rfind ( char c, std::size_t pos ) const
-{
+std::size_t String::rfind( char c, std::size_t pos ) const {
 	return mString.rfind( c, pos );
 }
 
-std::size_t String::copy ( StringBaseType* s, std::size_t n, std::size_t pos ) const
-{
+std::size_t String::copy( StringBaseType* s, std::size_t n, std::size_t pos ) const {
 	return mString.copy( s, n, pos );
 }
 
-String String::substr ( std::size_t pos, std::size_t n ) const
-{
+String String::substr( std::size_t pos, std::size_t n ) const {
 	return String( mString.substr( pos, n ) );
 }
 
-int String::compare ( const String& str ) const
-{
+int String::compare( const String& str ) const {
 	return mString.compare( str.mString );
 }
 
-int String::compare ( const char* s ) const
-{
+int String::compare( const char* s ) const {
 	return compare( String( s ) );
 }
 
-int String::compare ( std::size_t pos1, std::size_t n1, const String& str ) const
-{
+int String::compare( std::size_t pos1, std::size_t n1, const String& str ) const {
 	return mString.compare( pos1, n1, str.mString );
 }
 
-int String::compare ( std::size_t pos1, std::size_t n1, const char* s) const
-{
+int String::compare( std::size_t pos1, std::size_t n1, const char* s) const {
 	return compare( pos1, n1, String( s ) );
 }
 
-int String::compare ( std::size_t pos1, std::size_t n1, const String& str, std::size_t pos2, std::size_t n2 ) const
-{
+int String::compare( std::size_t pos1, std::size_t n1, const String& str, std::size_t pos2, std::size_t n2 ) const {
 	return mString.compare( pos1, n1, str.mString, pos2, n2 );
 }
 
-int String::compare ( std::size_t pos1, std::size_t n1, const char* s, std::size_t n2) const
-{
+int String::compare( std::size_t pos1, std::size_t n1, const char* s, std::size_t n2) const {
 	return compare( pos1, n1, String( s ), 0, n2 );
 }
 
-std::size_t String::find_first_of ( const String& str, std::size_t pos ) const
-{
+std::size_t String::find_first_of( const String& str, std::size_t pos ) const {
 	return mString.find_first_of( str.mString, pos );
 }
 
-std::size_t String::find_first_of ( const char* s, std::size_t pos, std::size_t n ) const
-{
+std::size_t String::find_first_of( const char* s, std::size_t pos, std::size_t n ) const {
 	return find_first_of( String( s ), pos );
 }
 
-std::size_t String::find_first_of ( const char* s, std::size_t pos ) const
-{
+std::size_t String::find_first_of( const char* s, std::size_t pos ) const {
 	return find_first_of( String( s ), pos );
 }
 
-std::size_t String::find_first_of ( StringBaseType c, std::size_t pos ) const
-{
+std::size_t String::find_first_of( StringBaseType c, std::size_t pos ) const {
 	return mString.find_first_of( c, pos );
 }
 
-std::size_t String::find_last_of ( const String& str, std::size_t pos ) const
-{
+std::size_t String::find_last_of( const String& str, std::size_t pos ) const {
 	return mString.find_last_of( str.mString, pos );
 }
 
-std::size_t String::find_last_of ( const char* s, std::size_t pos, std::size_t n ) const
-{
+std::size_t String::find_last_of( const char* s, std::size_t pos, std::size_t n ) const {
 	return find_last_of( String( s ), pos );
 }
 
-std::size_t String::find_last_of ( const char* s, std::size_t pos ) const
-{
+std::size_t String::find_last_of( const char* s, std::size_t pos ) const {
 	return find_last_of( String( s ), pos );
 }
 
-std::size_t String::find_last_of ( StringBaseType c, std::size_t pos) const
-{
+std::size_t String::find_last_of( StringBaseType c, std::size_t pos) const {
 	return mString.find_last_of( c, pos );
 }
 
-std::size_t String::find_first_not_of ( const String& str, std::size_t pos ) const
-{
+std::size_t String::find_first_not_of( const String& str, std::size_t pos ) const {
 	return mString.find_first_not_of( str.mString, pos );
 }
 
-std::size_t String::find_first_not_of ( const char* s, std::size_t pos, std::size_t n ) const
-{
+std::size_t String::find_first_not_of( const char* s, std::size_t pos, std::size_t n ) const {
 	return find_first_not_of( String( s ), pos );
 }
 
-std::size_t String::find_first_not_of ( const char* s, std::size_t pos ) const
-{
+std::size_t String::find_first_not_of( const char* s, std::size_t pos ) const {
 	return find_first_not_of( String( s ), pos );
 }
 
-std::size_t String::find_first_not_of ( StringBaseType c, std::size_t pos ) const
-{
+std::size_t String::find_first_not_of( StringBaseType c, std::size_t pos ) const {
 	return mString.find_first_not_of( c, pos );
 }
 
-std::size_t String::find_last_not_of ( const String& str, std::size_t pos ) const
-{
+std::size_t String::find_last_not_of( const String& str, std::size_t pos ) const {
 	return mString.find_last_not_of( str.mString, pos );
 }
 
-std::size_t String::find_last_not_of ( const char* s, std::size_t pos, std::size_t n ) const
-{
+std::size_t String::find_last_not_of( const char* s, std::size_t pos, std::size_t n ) const {
 	return find_last_not_of( String( s ), pos );
 }
 
-std::size_t String::find_last_not_of ( const char* s, std::size_t pos ) const
-{
+std::size_t String::find_last_not_of( const char* s, std::size_t pos ) const {
 	return find_last_not_of( String( s ), pos );
 }
 
-std::size_t String::find_last_not_of ( StringBaseType c, std::size_t pos ) const
-{
+std::size_t String::find_last_not_of( StringBaseType c, std::size_t pos ) const {
 	return mString.find_last_not_of( c, pos );
 }
 
-bool operator ==(const String& left, const String& right)
-{
+bool operator ==(const String& left, const String& right) {
 	return left.mString == right.mString;
 }
 
-bool operator !=(const String& left, const String& right)
-{
+bool operator !=(const String& left, const String& right) {
 	return !(left == right);
 }
 
-bool operator <(const String& left, const String& right)
-{
+bool operator <(const String& left, const String& right) {
 	return left.mString < right.mString;
 }
 
-bool operator >(const String& left, const String& right)
-{
+bool operator >(const String& left, const String& right) {
 	return right < left;
 }
 
-bool operator <=(const String& left, const String& right)
-{
+bool operator <=(const String& left, const String& right) {
 	return !(right < left);
 }
 
-bool operator >=(const String& left, const String& right)
-{
+bool operator >=(const String& left, const String& right) {
 	return !(left < right);
 }
 
-String operator +(const String& left, const String& right)
-{
+String operator +(const String& left, const String& right) {
 	String string = left;
 	string += right;