shattered_ogrerb 0.5.0.1

data/vendor/ogrerb/src_headers/OGRE/OgreAny.h

@@ -0,0 +1,405 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+    (Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Also see acknowledgements in Readme.html
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) Any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+Any WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place - Suite 330, Boston, MA 02111-1307, USA, or go to
+http://www.gnu.org/copyleft/lesser.txt.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+// -- Based on boost::any, original copyright information follows --
+// Copyright Kevlin Henney, 2000, 2001, 2002. All rights reserved.
+//
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompAnying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+// -- End original copyright --
+
+#ifndef __OGRE_ANY_H__
+#define __OGRE_ANY_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreException.h"
+#include "OgreString.h"
+#include <algorithm>
+#include <typeinfo>
+
+
+namespace Ogre
+{
+	/** Variant type that can hold Any other type.
+	*/
+    class Any
+    {
+    public: // constructors
+
+        Any()
+          : mContent(0)
+        {
+        }
+
+        template<typename ValueType>
+        explicit Any(const ValueType & value)
+          : mContent(new holder<ValueType>(value))
+        {
+        }
+
+        Any(const Any & other)
+          : mContent(other.mContent ? other.mContent->clone() : 0)
+        {
+        }
+
+        virtual ~Any()
+        {
+            delete mContent;
+        }
+
+    public: // modifiers
+
+        Any& swap(Any & rhs)
+        {
+            std::swap(mContent, rhs.mContent);
+            return *this;
+        }
+
+        template<typename ValueType>
+        Any& operator=(const ValueType & rhs)
+        {
+            Any(rhs).swap(*this);
+            return *this;
+        }
+
+        Any & operator=(const Any & rhs)
+        {
+            Any(rhs).swap(*this);
+            return *this;
+        }
+
+    public: // queries
+
+        bool isEmpty() const
+        {
+            return !mContent;
+        }
+
+        const std::type_info& getType() const
+        {
+            return mContent ? mContent->getType() : typeid(void);
+        }
+
+		inline friend std::ostream& operator <<
+			( std::ostream& o, const Any& v )
+		{
+			if (v.mContent)
+				v.mContent->writeToStream(o);
+			return o;
+		}
+
+
+    protected: // types
+
+        class placeholder
+        {
+        public: // structors
+    
+            virtual ~placeholder()
+            {
+            }
+
+        public: // queries
+
+            virtual const std::type_info& getType() const = 0;
+
+            virtual placeholder * clone() const = 0;
+    
+			virtual void writeToStream(std::ostream& o) = 0;
+
+        };
+
+        template<typename ValueType>
+        class holder : public placeholder
+        {
+        public: // structors
+
+            holder(const ValueType & value)
+              : held(value)
+            {
+            }
+
+        public: // queries
+
+            virtual const std::type_info & getType() const
+            {
+                return typeid(ValueType);
+            }
+
+            virtual placeholder * clone() const
+            {
+                return new holder(held);
+            }
+
+			virtual void writeToStream(std::ostream& o)
+			{
+				o << held;
+			}
+
+
+        public: // representation
+
+            ValueType held;
+
+        };
+
+
+
+    protected: // representation
+        placeholder * mContent;
+
+        template<typename ValueType>
+        friend ValueType * any_cast(Any *);
+
+
+    public: 
+
+	    template<typename ValueType>
+    	ValueType operator()() const
+    	{
+			if (!mContent) 
+			{
+				OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
+					"Bad cast from uninitialised Any", 
+					"Any::operator()");
+			}
+			else if(getType() == typeid(ValueType))
+			{
+             	return static_cast<Any::holder<ValueType> *>(mContent)->held;
+			}
+			else
+			{
+				StringUtil::StrStreamType str;
+				str << "Bad cast from type '" << getType().name() << "' "
+					<< "to '" << typeid(ValueType).name() << "'";
+				OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
+					 str.str(), 
+					"Any::operator()");
+			}
+		}
+
+		
+
+    };
+
+
+	/** Specialised Any class which has built in arithmetic operators, but can 
+		hold only types which support operator +,-,* and / .
+	*/
+	class AnyNumeric : public Any
+	{
+	public:
+		AnyNumeric()
+		: Any()
+		{
+		}
+
+		template<typename ValueType>
+		AnyNumeric(const ValueType & value)
+			
+		{
+			mContent = new numholder<ValueType>(value);
+		}
+
+		AnyNumeric(const AnyNumeric & other)
+            : Any()
+		{
+			mContent = other.mContent ? other.mContent->clone() : 0; 
+		}
+	protected:
+		class numplaceholder : public Any::placeholder
+		{
+		public: // structors
+
+			~numplaceholder()
+			{
+			}
+			virtual placeholder* add(placeholder* rhs) = 0;
+			virtual placeholder* subtract(placeholder* rhs) = 0;
+			virtual placeholder* multiply(placeholder* rhs) = 0;
+			virtual placeholder* multiply(Real factor) = 0;
+			virtual placeholder* divide(placeholder* rhs) = 0;
+		};
+
+		template<typename ValueType>
+		class numholder : public numplaceholder
+		{
+		public: // structors
+
+			numholder(const ValueType & value)
+				: held(value)
+			{
+			}
+
+		public: // queries
+
+			virtual const std::type_info & getType() const
+			{
+				return typeid(ValueType);
+			}
+
+			virtual placeholder * clone() const
+			{
+				return new numholder(held);
+			}
+
+			virtual placeholder* add(placeholder* rhs)
+			{
+				return new numholder(held + static_cast<numholder*>(rhs)->held);
+			}
+			virtual placeholder* subtract(placeholder* rhs)
+			{
+				return new numholder(held - static_cast<numholder*>(rhs)->held);
+			}
+			virtual placeholder* multiply(placeholder* rhs)
+			{
+				return new numholder(held * static_cast<numholder*>(rhs)->held);
+			}
+			virtual placeholder* multiply(Real factor)
+			{
+				return new numholder(held * factor);
+			}
+			virtual placeholder* divide(placeholder* rhs)
+			{
+				return new numholder(held / static_cast<numholder*>(rhs)->held);
+			}
+			virtual void writeToStream(std::ostream& o)
+			{
+				o << held;
+			}
+
+		public: // representation
+
+			ValueType held;
+
+		};
+
+		/// Construct from holder
+		AnyNumeric(placeholder* pholder)
+		{
+			mContent = pholder;
+		}
+
+	public:
+		AnyNumeric & operator=(const AnyNumeric & rhs)
+		{
+			AnyNumeric(rhs).swap(*this);
+			return *this;
+		}
+		AnyNumeric operator+(const AnyNumeric& rhs) const
+		{
+			return AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->add(rhs.mContent));
+		}
+		AnyNumeric operator-(const AnyNumeric& rhs) const
+		{
+			return AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->subtract(rhs.mContent));
+		}
+		AnyNumeric operator*(const AnyNumeric& rhs) const
+		{
+			return AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->multiply(rhs.mContent));
+		}
+		AnyNumeric operator*(Real factor) const
+		{
+			return AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->multiply(factor));
+		}
+		AnyNumeric operator/(const AnyNumeric& rhs) const
+		{
+			return AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->divide(rhs.mContent));
+		}
+		AnyNumeric& operator+=(const AnyNumeric& rhs)
+		{
+			*this = AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->add(rhs.mContent));
+			return *this;
+		}
+		AnyNumeric& operator-=(const AnyNumeric& rhs)
+		{
+			*this = AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->subtract(rhs.mContent));
+			return *this;
+		}
+		AnyNumeric& operator*=(const AnyNumeric& rhs)
+		{
+			*this = AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->multiply(rhs.mContent));
+			return *this;
+		}
+		AnyNumeric& operator/=(const AnyNumeric& rhs)
+		{
+			*this = AnyNumeric(
+				static_cast<numplaceholder*>(mContent)->divide(rhs.mContent));
+			return *this;
+		}
+
+
+
+
+	};
+
+
+    template<typename ValueType>
+    ValueType * any_cast(Any * operand)
+    {
+        return operand && operand->getType() == typeid(ValueType)
+                    ? &static_cast<Any::holder<ValueType> *>(operand->mContent)->held
+                    : 0;
+    }
+
+    template<typename ValueType>
+    const ValueType * any_cast(const Any * operand)
+    {
+        return any_cast<ValueType>(const_cast<Any *>(operand));
+    }
+
+    template<typename ValueType>
+    ValueType any_cast(const Any & operand)
+    {
+        const ValueType * result = any_cast<ValueType>(&operand);
+        if(!result)
+		{
+			StringUtil::StrStreamType str;
+			str << "Bad cast from type '" << operand.getType().name() << "' "
+				<< "to '" << typeid(ValueType).name() << "'";
+			OGRE_EXCEPT(Exception::ERR_INVALIDPARAMS,
+				str.str(), 
+				"Ogre::any_cast");
+		}
+        return *result;
+    }
+
+
+}
+
+#endif
+

data/vendor/ogrerb/src_headers/OGRE/OgreArchive.h

@@ -0,0 +1,191 @@
+/*
+-----------------------------------------------------------------------------
+This source file is part of OGRE
+(Object-oriented Graphics Rendering Engine)
+For the latest info, see http://www.ogre3d.org/
+
+Copyright (c) 2000-2006 Torus Knot Software Ltd
+Also see acknowledgements in Readme.html
+
+This program is free software; you can redistribute it and/or modify it under
+the terms of the GNU Lesser General Public License as published by the Free Software
+Foundation; either version 2 of the License, or (at your option) any later
+version.
+
+This program is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public License along with
+this program; if not, write to the Free Software Foundation, Inc., 59 Temple
+Place - Suite 330, Boston, MA 02111-1307, USA, or go to
+http://www.gnu.org/copyleft/lesser.txt.
+
+You may alternatively use this source under the terms of a specific version of
+the OGRE Unrestricted License provided you have obtained such a license from
+Torus Knot Software Ltd.
+-----------------------------------------------------------------------------
+*/
+#ifndef _Archive_H__
+#define _Archive_H__
+
+#include "OgrePrerequisites.h"
+#include "OgreString.h"
+#include "OgreDataStream.h"
+#include "OgreSharedPtr.h"
+#include "OgreStringVector.h"
+
+namespace Ogre {
+
+    /** Information about a file/directory within the archive will be
+    returned using a FileInfo struct.
+    @see
+    Archive
+    */
+    struct FileInfo {
+		/// The archive in which the file has been found (for info when performing
+		/// multi-Archive searches, note you should still open through ResourceGroupManager)
+		Archive* archive;
+        /// The file's fully qualified name
+        String filename;
+        /// Path name; separated by '/' and ending with '/'
+        String path;
+        /// Base filename
+        String basename;
+        /// Compressed size
+        size_t compressedSize;
+        /// Uncompressed size
+        size_t uncompressedSize;
+    };
+
+    typedef std::vector<FileInfo> FileInfoList;
+    typedef SharedPtr<FileInfoList> FileInfoListPtr;
+
+    /** Archive-handling class.
+    @remarks
+        An archive is a generic term for a container of files. This may be a
+        filesystem folder, it may be a compressed archive, it may even be 
+        a remote location shared on the web. This class is designed to be 
+        subclassed to provide access to a range of file locations. 
+    @par
+        Instances of this class are never constructed or even handled by end-user
+        applications. They are constructed by custom ArchiveFactory classes, 
+        which plugins can register new instances of using ArchiveManager. 
+        End-user applications will typically use ResourceManager or 
+        ResourceGroupManager to manage resources at a higher level, rather than 
+        reading files directly through this class. Doing it this way allows you
+        to benefit from OGRE's automatic searching of multiple file locations 
+        for the resources you are looking for.
+    */
+    class _OgreExport Archive  
+    {
+    protected:
+        /// Archive name
+        String mName; 
+        /// Archive type code
+        String mType;
+    public:
+
+
+        /** Constructor - don't call direct, used by ArchiveFactory.
+        */
+        Archive( const String& name, const String& archType )
+            : mName(name), mType(archType) {}
+
+        /** Default destructor.
+        */
+        virtual ~Archive() {}
+
+		/// Get the name of this archive
+		const String& getName(void) const { return mName; }
+
+        /// Returns whether this archive is case sensitive in the way it matches files
+        virtual bool isCaseSensitive(void) const = 0;
+
+        /** Loads the archive.
+        @remarks
+            This initializes all the internal data of the class.
+        @warning
+            Do not call this function directly, it is ment to be used
+            only by the ArchiveManager class.
+        */
+        virtual void load() = 0;
+
+        /** Unloads the archive.
+        @warning
+            Do not call this function directly, it is ment to be used
+            only by the ArchiveManager class.
+        */
+        virtual void unload() = 0;
+
+        /** Open a stream on a given file. 
+        @note
+            There is no equivalent 'close' method; the returned stream
+            controls the lifecycle of this file operation.
+        @param filename The fully qualified name of the file
+        @returns A shared pointer to a DataStream which can be used to 
+            read / write the file. If the file is not present, returns a null
+			shared pointer.
+        */
+        virtual DataStreamPtr open(const String& filename) const = 0;
+
+        /** List all file names in the archive.
+        @note
+            This method only returns filenames, you can also retrieve other
+            information using listFileInfo.
+        @param recursive Whether all paths of the archive are searched (if the 
+            archive has a concept of that)
+        @param dirs Set to true if you want the directories to be listed
+            instead of files
+        @returns A list of filenames matching the criteria, all are fully qualified
+        */
+        virtual StringVectorPtr list(bool recursive = true, bool dirs = false) = 0;
+        
+        /** List all files in the archive with accompanying information.
+        @param recursive Whether all paths of the archive are searched (if the 
+            archive has a concept of that)
+        @param dirs Set to true if you want the directories to be listed
+            instead of files
+        @returns A list of structures detailing quite a lot of information about
+            all the files in the archive.
+        */
+        virtual FileInfoListPtr listFileInfo(bool recursive = true, bool dirs = false) = 0;
+
+        /** Find all file or directory names matching a given pattern
+            in this archive.
+        @note
+            This method only returns filenames, you can also retrieve other
+            information using findFileInfo.
+        @param pattern The pattern to search for; wildcards (*) are allowed
+        @param recursive Whether all paths of the archive are searched (if the 
+            archive has a concept of that)
+        @param dirs Set to true if you want the directories to be listed
+            instead of files
+        @returns A list of filenames matching the criteria, all are fully qualified
+        */
+        virtual StringVectorPtr find(const String& pattern, bool recursive = true,
+            bool dirs = false) = 0;
+
+        /** Find out if the named file exists (note: fully qualified filename required) */
+        virtual bool exists(const String& filename) = 0; 
+
+        /** Find all files or directories matching a given pattern in this
+            archive and get some detailed information about them.
+        @param pattern The pattern to search for; wildcards (*) are allowed
+        @param recursive Whether all paths of the archive are searched (if the 
+        archive has a concept of that)
+        @param dirs Set to true if you want the directories to be listed
+            instead of files
+        @returns A list of file information structures for all files matching 
+            the criteria.
+        */
+        virtual FileInfoListPtr findFileInfo(const String& pattern, 
+            bool recursive = true, bool dirs = false) = 0;
+
+        /// Return the type code of this Archive
+        const String& getType(void) const { return mType; }
+        
+    };
+}
+
+#endif