ruby-ogre 0.0.1-x86-linux

data/deps/include/OGRE/OgreStreamSerialiser.h

@@ -0,0 +1,386 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+*/
+#ifndef __StreamSerialiser_H__
+#define __StreamSerialiser_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreDataStream.h"
+
+
+namespace Ogre 
+{
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup Resources
+	*  @{
+	*/
+
+	/** Utility class providing helper methods for reading / writing 
+		structured data held in a DataStream.
+	@remarks
+		The structure of a file read / written by this class is a series of 
+		'chunks'. A chunk-based format has the advantage of being extensible later, 
+		and it's robust, in that a reader can skip chunks that they are not 
+		able (or willing) to process.
+	@par
+		Chunks are contained serially in the file, but they can also be 
+		nested in order both to provide context, and to group chunks together for 
+		potential skipping. 
+	@par
+		The data format of a chunk is as follows:
+		-# Chunk ID (32-bit uint). This can be any number unique in a context, except the numbers 0x0000, 0x0001 and 0x1000, which are reserved for Ogre's use
+		-# Chunk version (16-bit uint). Chunks can change over time so this version number reflects that
+		-# Length (32-bit uint). The length of the chunk data section, including nested chunks. Note that
+			this length excludes this header, but includes the header of any nested chunks. 
+		-# Checksum (32-bit uint). Checksum value generated from the above - basically lets us check this is a valid chunk.
+		-# Chunk data
+		The 'Chunk data' section will contain chunk-specific data, which may include
+		other nested chunks.
+	*/
+	class _OgreExport StreamSerialiser : public StreamAlloc
+	{
+	public:
+		/// The endianness of files
+		enum Endian
+		{
+			/// Automatically determine endianness
+			ENDIAN_AUTO,
+			/// Use big endian (0x1000 is serialised as 0x10 0x00)
+			ENDIAN_BIG,
+			/// Use little endian (0x1000 is serialised as 0x00 0x10)
+			ENDIAN_LITTLE
+		};
+
+		/// The storage format of Real values
+		enum RealStorageFormat
+		{
+			/// Real is stored as float, reducing precision if you're using OGRE_DOUBLE_PRECISION
+			REAL_FLOAT,
+			/// Real as stored as double, not useful unless you're using OGRE_DOUBLE_PRECISION
+			REAL_DOUBLE
+		};
+
+
+		/// Definition of a chunk of data in a file
+		struct Chunk : public StreamAlloc
+		{
+			/// Identifier of the chunk (for example from makeIdentifier)  (stored)
+			uint32 id;
+			/// Version of the chunk (stored)
+			uint16 version;
+			/// Length of the chunk data in bytes, excluding the header of this chunk (stored)
+			uint32 length;
+			/// Location of the chunk (header) in bytes from the start of a stream (derived)
+			uint32 offset;
+
+			Chunk() : id(0), version(1), length(0), offset(0) {}
+		};
+
+		/** Constructor.
+		@param stream The stream on which you will read / write data.
+		@param endianMode The endian mode in which to read / writedata. If left at
+			the default, when writing the endian mode will be the native platform mode, 
+			and when reading it's expected that the first chunk encountered will be 
+			the header chunk, which will determine the endian mode.
+		@param autoHeader If true, the first write or read to this stream will 
+			automatically read / write the header too. This is required if you
+			set endianMode to ENDIAN_AUTO, but if you manually set the endian mode, 
+			then you can skip writing / reading the header if you wish, if for example
+			this stream is midway through a file which has already included header
+			information.
+		@param realFormat Set the format you want to write reals in. Only useful for files that 
+			you're writing (since when reading this is picked up from the file), 
+			and can only be changed if autoHeader is true, since real format is stored in the header. 
+			Defaults to float unless you're using OGRE_DOUBLE_PRECISION.
+		*/
+		StreamSerialiser(const DataStreamPtr& stream, Endian endianMode = ENDIAN_AUTO, 
+			bool autoHeader = true, 
+#if OGRE_DOUBLE_PRECISION
+			RealStorageFormat realFormat = REAL_DOUBLE
+#else
+			RealStorageFormat realFormat = REAL_FLOAT
+#endif
+			);
+		virtual ~StreamSerialiser();
+
+		/** Get the endian mode.
+		@remarks
+			If the result is ENDIAN_AUTO, this mode will change when the first piece of
+			data is read / written. 
+		*/
+		virtual Endian getEndian() const { return mEndian; }
+
+		/** Pack a 4-character code into a 32-bit identifier.
+		@remarks
+			You can use this to generate id's for your chunks based on friendlier
+			4-character codes rather than assigning numerical IDs, if you like.
+		@param code String to pack - must be 4 characters.
+		*/
+		static uint32 makeIdentifier(const String& code);
+
+		/** Report the current depth of the chunk nesting, whether reading or writing. 
+		@remarks
+			Returns how many levels of nested chunks are currently being processed, 
+			either writing or reading. In order to tidily finish, you must call
+			read/writeChunkEnd this many times.
+		*/
+		size_t getCurrentChunkDepth() const { return mChunkStack.size(); }
+
+		/** Get the ID of the chunk that's currently being read/written, if any.
+		@return The id of the current chunk being read / written (at the tightest
+			level of nesting), or zero if no chunk is being processed.
+		*/
+		uint32 getCurrentChunkID() const;
+
+		/** Get the current byte position relative to the start of the data section
+			of the last chunk that was read or written. 
+		@return the offset. Note that a return value of 0 means that either the
+			position is at the start of the chunk data section (ie right after the
+			header), or that no chunk is currently active. Use getCurrentChunkID
+			or getCurrentChunkDepth to determine if a chunk is active.
+		*/
+		size_t getOffsetFromChunkStart() const;
+
+		/** Reads the start of the next chunk in the file.
+		@remarks
+			Files are serialised in a chunk-based manner, meaning that each section
+			of data is prepended by a chunk header. After reading this chunk header, 
+			the next set of data is available directly afterwards. 
+		@note
+			When you have finished with this chunk, you should call readChunkEnd. 
+			This will perform a bit of validation and clear the chunk from 
+			the stack. 
+		@return The Chunk that comes next
+		*/
+		virtual const Chunk* readChunkBegin();
+
+		/** Reads the start of the next chunk so long as it's of a given ID and version.
+		@remarks
+			This method operates like readChunkBegin, except it checks the ID and
+			version.
+		@param id The ID you're expecting. If the next chunk isn't of this ID, then
+			the chunk read is undone and the method returns null.
+		@param maxVersion The maximum version you're able to process. If the ID is correct
+			but the version	exceeds what is passed in here, the chunk is skipped over,
+			the problem logged and null is returned. 
+		@param msg Descriptive text added to the log if versions are not compatible
+		@return The chunk if it passes the validation.
+		*/
+		virtual const Chunk* readChunkBegin(uint32 id, uint16 maxVersion, const String& msg = StringUtil::BLANK);
+
+		/** Call this to 'rewind' the stream to just before the start of the current
+			chunk. 
+		@remarks
+			The most common case of wanting to use this is if you'd calledReadChunkBegin(), 
+			but the chunk you read wasn't one you wanted to process, and rather than
+			skipping over it (which readChunkEnd() would do), you want to backtrack
+			and give something else an opportunity to read it. 
+		@param id The id of the chunk that you were reading (for validation purposes)
+		*/
+		virtual void undoReadChunk(uint32 id);
+
+		/** Call this to 'peek' at the next chunk ID without permanently moving the stream pointer. */
+		virtual uint32 peekNextChunkID(); 
+
+		/** Finish the reading of a chunk.
+		@remarks
+			You can call this method at any point after calling readChunkBegin, even
+			if you didn't read all the rest of the data in the chunk. If you did 
+			not read to the end of a chunk, this method will automatically skip 
+			over the remainder of the chunk and position the stream just after it. 
+		@param id The id of the chunk that you were reading (for validation purposes)
+		*/
+		virtual void readChunkEnd(uint32 id);
+
+		/** Return whether the current data pointer is at the end of the current chunk.
+		@param id The id of the chunk that you were reading (for validation purposes)
+		*/
+		virtual bool isEndOfChunk(uint32 id);
+
+		/// Reports whether the stream is at the end of file
+		virtual bool eof() const;
+
+		/** Get the definition of the current chunk being read (if any). */
+		virtual const Chunk* getCurrentChunk() const;
+
+		/** Begin writing a new chunk.
+		@remarks
+			This starts the process of writing a new chunk to the stream. This will 
+			write the chunk header for you, and store a pointer so that the
+			class can automatically go back and fill in the size for you later
+			should you need it to. If you have already begun a chunk without ending
+			it, then this method will start a nested chunk within it. Once written, 
+			you can then start writing chunk-specific data into your stream.
+		@note If this is the first chunk in the file
+		@param id The identifier of the new chunk. Any value that's unique in the
+			file context is valid, except for the numbers 0x0001 and 0x1000 which are reserved
+			for internal header identification use. 
+		@param version The version of the chunk you're writing
+		*/
+		virtual void writeChunkBegin(uint32 id, uint16 version = 1);
+		/** End writing a chunk. 
+		@param id The identifier of the chunk - this is really just a safety check, 
+			since you can only end the chunk you most recently started.
+		*/
+		virtual void writeChunkEnd(uint32 id);
+
+		/** Write arbitrary data to a stream. 
+		@param buf Pointer to bytes
+		@param size The size of each element to write; each will be endian-flipped if
+			necessary
+		@param count The number of elements to write
+		*/
+		virtual void writeData(const void* buf, size_t size, size_t count);
+
+		/** Catch-all method to write primitive types. */
+		template <typename T>
+		void write(const T* pT, size_t count = 1)
+		{
+			writeData(pT, sizeof(T), count);
+		}
+
+		// Special-case Real since we need to deal with single/double precision
+		virtual void write(const Real* val, size_t count = 1);
+
+		virtual void write(const Vector2* vec, size_t count = 1);
+		virtual void write(const Vector3* vec, size_t count = 1);
+		virtual void write(const Vector4* vec, size_t count = 1);
+		virtual void write(const Quaternion* q, size_t count = 1);
+		virtual void write(const Matrix3* m, size_t count = 1);
+		virtual void write(const Matrix4* m, size_t count = 1);
+		virtual void write(const String* string);
+		virtual void write(const AxisAlignedBox* aabb, size_t count = 1);
+		virtual void write(const Sphere* sphere, size_t count = 1);
+		virtual void write(const Plane* plane, size_t count = 1);
+		virtual void write(const Ray* ray, size_t count = 1);
+		virtual void write(const Radian* angle, size_t count = 1);
+		virtual void write(const Node* node, size_t count = 1);
+		virtual void write(const bool* boolean, size_t count = 1);
+
+
+		/** Read arbitrary data from a stream. 
+		@param buf Pointer to bytes
+		@param size The size of each element to read; each will be endian-flipped if
+		necessary
+		@param count The number of elements to read
+		*/
+		virtual void readData(void* buf, size_t size, size_t count);
+
+		/** Catch-all method to read primitive types. */
+		template <typename T>
+		void read(T* pT, size_t count = 1)
+		{
+			readData(pT, sizeof(T), count);
+		}
+
+		// Special case Real, single/double-precision issues
+		virtual void read(Real* val, size_t count = 1);
+
+		/// read a Vector3
+		virtual void read(Vector2* vec, size_t count = 1);
+		virtual void read(Vector3* vec, size_t count = 1);
+		virtual void read(Vector4* vec, size_t count = 1);
+		virtual void read(Quaternion* q, size_t count = 1);
+		virtual void read(Matrix3* m, size_t count = 1);
+		virtual void read(Matrix4* m, size_t count = 1);
+		virtual void read(String* string);
+		virtual void read(AxisAlignedBox* aabb, size_t count = 1);
+		virtual void read(Sphere* sphere, size_t count = 1);
+		virtual void read(Plane* plane, size_t count = 1);
+		virtual void read(Ray* ray, size_t count = 1);
+		virtual void read(Radian* angle, size_t count = 1);
+		virtual void read(Node* node, size_t count = 1);
+		virtual void read(bool* val, size_t count = 1);
+
+	protected:
+		DataStreamPtr mStream;
+		Endian mEndian;
+		bool mFlipEndian;
+		bool mReadWriteHeader;
+		RealStorageFormat mRealFormat;
+		typedef deque<Chunk*>::type ChunkStack;
+		/// Current list of open chunks
+		ChunkStack mChunkStack;
+
+		static uint32 HEADER_ID;
+		static uint32 REVERSE_HEADER_ID;
+		static uint32 CHUNK_HEADER_SIZE;
+
+		virtual Chunk* readChunkImpl();
+		virtual void writeChunkImpl(uint32 id, uint16 version);
+		virtual void readHeader();
+		virtual void writeHeader();
+		virtual uint32 calculateChecksum(Chunk* c);
+		virtual void checkStream(bool failOnEof = false, 
+			bool validateReadable = false, bool validateWriteable = false) const;
+
+		virtual void flipEndian(void * pData, size_t size, size_t count);
+		virtual void flipEndian(void * pData, size_t size);
+		virtual void determineEndianness();
+		virtual Chunk* popChunk(uint id);
+
+		virtual void writeFloatsAsDoubles(const float* val, size_t count);
+		virtual void writeDoublesAsFloats(const double* val, size_t count);
+		virtual void readFloatsAsDoubles(double* val, size_t count);
+		virtual void readDoublesAsFloats(float* val, size_t count);
+		template <typename T, typename U>
+		void writeConverted(const T* src, U typeToWrite, size_t count)
+		{
+			U* tmp = OGRE_ALLOC_T(U, count, MEMCATEGORY_GENERAL);
+			U* pDst = tmp;
+			const T* pSrc = src;
+			for (size_t i = 0; i < count; ++i)
+				*pDst++ = static_cast<U>(*pSrc++);
+			
+			writeData(tmp, sizeof(U), count);
+
+			OGRE_FREE(tmp, MEMCATEGORY_GENERAL);
+		}
+		template <typename T, typename U>
+		void readConverted(T* dst, U typeToRead, size_t count)
+		{
+			U* tmp = OGRE_ALLOC_T(U, count, MEMCATEGORY_GENERAL);
+			readData(tmp, sizeof(U), count);
+
+			T* pDst = dst;
+			const U* pSrc = tmp;
+			for (size_t i = 0; i < count; ++i)
+				*pDst++ = static_cast<T>(*pSrc++);
+
+
+			OGRE_FREE(tmp, MEMCATEGORY_GENERAL);
+		}
+
+	};
+	/** @} */
+	/** @} */
+}
+
+#endif
+

data/deps/include/OGRE/OgreString.h

@@ -0,0 +1,223 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2012 Torus Knot Software Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+-----------------------------------------------------------------------------
+*/
+#ifndef _String_H__
+#define _String_H__
+
+#include "OgrePrerequisites.h"
+
+// If we're using the GCC 3.1 C++ Std lib
+#if OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 310 && !defined(STLPORT)
+
+// For gcc 4.3 see http://gcc.gnu.org/gcc-4.3/changes.html
+#   if OGRE_COMP_VER >= 430
+#       include <tr1/unordered_map> 
+#   else
+#       include <ext/hash_map>
+namespace __gnu_cxx
+{
+    template <> struct hash< Ogre::_StringBase >
+    {
+        size_t operator()( const Ogre::_StringBase _stringBase ) const
+        {
+            /* This is the PRO-STL way, but it seems to cause problems with VC7.1
+               and in some other cases (although I can't recreate it)
+            hash<const char*> H;
+            return H(_stringBase.c_str());
+            */
+            /** This is our custom way */
+            register size_t ret = 0;
+            for( Ogre::_StringBase::const_iterator it = _stringBase.begin(); it != _stringBase.end(); ++it )
+                ret = 5 * ret + *it;
+
+            return ret;
+        }
+    };
+}
+#   endif
+
+#endif
+
+namespace Ogre {
+	/** \addtogroup Core
+	*  @{
+	*/
+	/** \addtogroup General
+	*  @{
+	*/
+
+    /** Utility class for manipulating Strings.  */
+    class _OgreExport StringUtil
+    {
+	public:
+		typedef StringStream StrStreamType;
+
+        /** Removes any whitespace characters, be it standard space or
+            TABs and so on.
+            @remarks
+                The user may specify wether they want to trim only the
+                beginning or the end of the String ( the default action is
+                to trim both).
+        */
+        static void trim( String& str, bool left = true, bool right = true );
+
+        /** Returns a StringVector that contains all the substrings delimited
+            by the characters in the passed <code>delims</code> argument.
+            @param
+                delims A list of delimiter characters to split by
+            @param
+                maxSplits The maximum number of splits to perform (0 for unlimited splits). If this
+                parameters is > 0, the splitting process will stop after this many splits, left to right.
+            @param
+                preserveDelims Flag to determine if delimiters should be saved as substrings
+        */
+		static vector<String>::type split( const String& str, const String& delims = "\t\n ", unsigned int maxSplits = 0, bool preserveDelims = false);
+
+		/** Returns a StringVector that contains all the substrings delimited
+            by the characters in the passed <code>delims</code> argument, 
+			or in the <code>doubleDelims</code> argument, which is used to include (normal) 
+			delimeters in the tokenised string. For example, "strings like this".
+            @param
+                delims A list of delimiter characters to split by
+			@param
+                delims A list of double delimeters characters to tokenise by
+            @param
+                maxSplits The maximum number of splits to perform (0 for unlimited splits). If this
+                parameters is > 0, the splitting process will stop after this many splits, left to right.
+        */
+		static vector<String>::type tokenise( const String& str, const String& delims = "\t\n ", const String& doubleDelims = "\"", unsigned int maxSplits = 0);
+
+		/** Lower-cases all the characters in the string.
+        */
+        static void toLowerCase( String& str );
+
+        /** Upper-cases all the characters in the string.
+        */
+        static void toUpperCase( String& str );
+
+
+        /** Returns whether the string begins with the pattern passed in.
+        @param pattern The pattern to compare with.
+        @param lowerCase If true, the start of the string will be lower cased before
+            comparison, pattern should also be in lower case.
+        */
+        static bool startsWith(const String& str, const String& pattern, bool lowerCase = true);
+
+        /** Returns whether the string ends with the pattern passed in.
+        @param pattern The pattern to compare with.
+        @param lowerCase If true, the end of the string will be lower cased before
+            comparison, pattern should also be in lower case.
+        */
+        static bool endsWith(const String& str, const String& pattern, bool lowerCase = true);
+
+        /** Method for standardising paths - use forward slashes only, end with slash.
+        */
+        static String standardisePath( const String &init);
+		/** Returns a normalized version of a file path
+		This method can be used to make file path strings which point to the same directory  
+		but have different texts to be normalized to the same text. The function:
+		- Transforms all backward slashes to forward slashes.
+		- Removes repeating slashes.
+		- Removes initial slashes from the beginning of the path.
+		- Removes ".\" and "..\" meta directories.
+		- Sets all characters to lowercase (if requested)
+		@param init The file path to normalize.
+		@param makeLowerCase If true, transforms all characters in the string to lowercase.
+		*/
+       static String normalizeFilePath(const String& init, bool makeLowerCase = true);
+
+
+        /** Method for splitting a fully qualified filename into the base name
+            and path.
+        @remarks
+            Path is standardised as in standardisePath
+        */
+        static void splitFilename(const String& qualifiedName,
+            String& outBasename, String& outPath);
+
+		/** Method for splitting a fully qualified filename into the base name,
+		extension and path.
+		@remarks
+		Path is standardised as in standardisePath
+		*/
+		static void splitFullFilename(const Ogre::String& qualifiedName, 
+			Ogre::String& outBasename, Ogre::String& outExtention, 
+			Ogre::String& outPath);
+
+		/** Method for splitting a filename into the base name
+		and extension.
+		*/
+		static void splitBaseFilename(const Ogre::String& fullName, 
+			Ogre::String& outBasename, Ogre::String& outExtention);
+
+
+        /** Simple pattern-matching routine allowing a wildcard pattern.
+        @param str String to test
+        @param pattern Pattern to match against; can include simple '*' wildcards
+        @param caseSensitive Whether the match is case sensitive or not
+        */
+        static bool match(const String& str, const String& pattern, bool caseSensitive = true);
+
+
+		/** replace all instances of a sub-string with a another sub-string.
+		@param source Source string
+		@param replaceWhat Sub-string to find and replace
+		@param replaceWithWhat Sub-string to replace with (the new sub-string)
+		@return An updated string with the sub-string replaced
+		*/
+		static const String replaceAll(const String& source, const String& replaceWhat, const String& replaceWithWhat);
+
+        /// Constant blank string, useful for returning by ref where local does not exist
+        static const String BLANK;
+    };
+
+
+#if OGRE_COMPILER == OGRE_COMPILER_GNUC && OGRE_COMP_VER >= 310 && !defined(STLPORT)
+#   if OGRE_COMP_VER < 430
+	typedef ::__gnu_cxx::hash< _StringBase > _StringHash;
+#   else
+	typedef ::std::tr1::hash< _StringBase > _StringHash;
+#   endif
+#elif OGRE_COMPILER == OGRE_COMPILER_CLANG
+#   if defined(_LIBCPP_VERSION)
+	typedef ::std::hash< _StringBase > _StringHash;
+#   else
+	typedef ::std::tr1::hash< _StringBase > _StringHash;
+#   endif
+#elif OGRE_COMPILER == OGRE_COMPILER_MSVC && OGRE_COMP_VER >= 1600 && !defined(STLPORT) // VC++ 10.0
+	typedef ::std::tr1::hash< _StringBase > _StringHash;
+#elif !defined( _STLP_HASH_FUN_H )
+	typedef stdext::hash_compare< _StringBase, std::less< _StringBase > > _StringHash;
+#else
+	typedef std::hash< _StringBase > _StringHash;
+#endif 
+	/** @} */
+	/** @} */
+
+} // namespace Ogre
+
+#endif // _String_H__