C++11-Support: remove boost.

code/BoostWorkaround/boost/LICENSE_1_0.txt

@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

code/BoostWorkaround/boost/foreach.hpp

@@ -1,99 +0,0 @@
-
-#ifndef BOOST_FOREACH
-
-///////////////////////////////////////////////////////////////////////////////
-// A stripped down version of FOREACH for
-// illustration purposes. NOT FOR GENERAL USE.
-// For a complete implementation, see BOOST_FOREACH at
-// http://boost-sandbox.sourceforge.net/vault/index.php?directory=eric_niebler
-//
-// Copyright 2004 Eric Niebler.
-// 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)
-//
-// Adapted to Assimp November 29th, 2008 (Alexander Gessler).
-// Added code to handle both const and non-const iterators, simplified some
-// parts.
-///////////////////////////////////////////////////////////////////////////////
-
-namespace boost {
-namespace foreach_detail {
-
-///////////////////////////////////////////////////////////////////////////////
-// auto_any
-
-struct auto_any_base
-{
-    operator bool() const { return false; }
-};
-
-template<typename T>
-struct auto_any : auto_any_base
-{
-    auto_any(T const& t) : item(t) {}
-    mutable T item;
-};
-
-template<typename T>
-T& auto_any_cast(auto_any_base const& any)
-{
-    return static_cast<auto_any<T> const&>(any).item;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// FOREACH helper function
-
-template<typename T>
-auto_any<typename T::const_iterator> begin(T const& t)
-{
-    return t.begin();
-}
-
-template<typename T>
-auto_any<typename T::const_iterator> end(T const& t)
-{
-    return t.end();
-}
-
-// iterator
-template<typename T>
-bool done(auto_any_base const& cur, auto_any_base const& end, T&)
-{
-    typedef typename T::iterator iter_type;
-    return auto_any_cast<iter_type>(cur) == auto_any_cast<iter_type>(end);
-}
-
-template<typename T>
-void next(auto_any_base const& cur, T&)
-{
-    ++auto_any_cast<typename T::iterator>(cur);
-}
-
-template<typename T>
-typename T::reference deref(auto_any_base const& cur, T&)
-{
-    return *auto_any_cast<typename T::iterator>(cur);
-}
-
-template<typename T>
-typename T::const_reference deref(auto_any_base const& cur, const T&)
-{
-    return *auto_any_cast<typename T::iterator>(cur);
-}
-
-} // end foreach_detail
-
-///////////////////////////////////////////////////////////////////////////////
-// FOREACH
-
-#define BOOST_FOREACH(item, container)                      \
-	if(boost::foreach_detail::auto_any_base const& foreach_magic_b = boost::foreach_detail::begin(container)) {} else       \
-    if(boost::foreach_detail::auto_any_base const& foreach_magic_e = boost::foreach_detail::end(container))   {} else       \
-    for(;!boost::foreach_detail::done(foreach_magic_b,foreach_magic_e,container);  boost::foreach_detail::next(foreach_magic_b,container))   \
-        if (bool ugly_and_unique_break = false) {} else							\
-        for(item = boost::foreach_detail::deref(foreach_magic_b,container); !ugly_and_unique_break; ugly_and_unique_break = true)
-
-} // end boost
-
-#endif

code/BoostWorkaround/boost/format.hpp

@@ -1,82 +0,0 @@
-
-
-
-/* DEPRECATED! - use code/TinyFormatter.h instead.
- *
- *
- * */
-
-#ifndef AI_BOOST_FORMAT_DUMMY_INCLUDED
-#define AI_BOOST_FORMAT_DUMMY_INCLUDED
-
-#if (!defined BOOST_FORMAT_HPP) || (defined ASSIMP_FORCE_NOBOOST)
-
-#include <string>
-#include <vector>
-#include <sstream> 
-
-namespace boost
-{
-
-
-	class format
-	{
-	public:
-		format (const std::string& _d)
-			: d(_d)
-		{
-		}
-
-		template <typename T>
-		format& operator % (T in) 
-		{
-			// XXX add replacement for boost::lexical_cast?
-			
-			std::ostringstream ss;
-			ss << in; // note: ss cannot be an rvalue, or  the global operator << (const char*) is not called for T == const char*.
-			chunks.push_back( ss.str());
-			return *this;
-		}
-
-
-		operator std::string () const {
-			std::string res; // pray for NRVO to kick in
-
-			size_t start = 0, last = 0;
-
-			std::vector<std::string>::const_iterator chunkin = chunks.begin();
-
-			for ( start = d.find('%');start != std::string::npos;  start = d.find('%',last)) {
-				res += d.substr(last,start-last);
-				last = start+2;
-				if (d[start+1] == '%') {
-					res += "%";
-					continue;
-				}
-
-				if (chunkin == chunks.end()) {
-					break;
-				}
-
-				res += *chunkin++;
-			}
-			res += d.substr(last);
-			return res;
-		}
-
-	private:
-		std::string d;
-		std::vector<std::string> chunks;
-	};
-
-	inline std::string str(const std::string& s) {
-		return s;
-	} 
-}
-
-
-#else
-#	error "format.h was already included"
-#endif //
-#endif // !! AI_BOOST_FORMAT_DUMMY_INCLUDED
-

code/BoostWorkaround/boost/lexical_cast.hpp

@@ -1,26 +0,0 @@
-/// A quick replacement for boost::lexical_cast for all the Boost haters out there
-
-#ifndef __AI_BOOST_WORKAROUND_LEXICAL_CAST
-#define __AI_BOOST_WORKAROUND_LEXICAL_CAST
-
-#include <sstream>
-
-namespace boost
-{
-
-	/// A quick replacement for boost::lexical_cast - should work for all types a stringstream can handle
-	template <typename TargetType, typename SourceType>
-	TargetType lexical_cast( const SourceType& source)
-	{
-		std::stringstream stream;
-		TargetType result;
-
-		stream << source;
-		stream >> result;
-		return result;
-	}
-
-} // namespace boost
-
-#endif // __AI_BOOST_WORKAROUND_LEXICAL_CAST
-

code/BoostWorkaround/boost/make_shared.hpp

@@ -1,57 +0,0 @@
-
-// please note that this replacement implementation does not
-// provide the performance benefit of the original, which
-// makes only one allocation as opposed to two allocations
-// (smart pointer counter and payload) which are usually
-// required if object and smart pointer are constructed
-// independently.
-
-#ifndef INCLUDED_AI_BOOST_MAKE_SHARED
-#define INCLUDED_AI_BOOST_MAKE_SHARED
-
-
-namespace boost {
-
-	template <typename T>
-	shared_ptr<T> make_shared() {
-		return shared_ptr<T>(new T());
-	}
-
-	template <typename T, typename T0>
-	shared_ptr<T> make_shared(const T0& t0) {
-		return shared_ptr<T>(new T(t0));
-	}
-
-	template <typename T, typename T0,typename T1>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1) {
-		return shared_ptr<T>(new T(t0,t1));
-	}
-
-	template <typename T, typename T0,typename T1,typename T2>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1, const T2& t2) {
-		return shared_ptr<T>(new T(t0,t1,t2));
-	}
-
-	template <typename T, typename T0,typename T1,typename T2,typename T3>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
-		return shared_ptr<T>(new T(t0,t1,t2,t3));
-	}
-
-	template <typename T, typename T0,typename T1,typename T2,typename T3, typename T4>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
-		return shared_ptr<T>(new T(t0,t1,t2,t3,t4));
-	}
-
-	template <typename T, typename T0,typename T1,typename T2,typename T3, typename T4, typename T5>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
-		return shared_ptr<T>(new T(t0,t1,t2,t3,t4,t5));
-	}
-
-	template <typename T, typename T0,typename T1,typename T2,typename T3, typename T4, typename T5, typename T6>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) {
-		return shared_ptr<T>(new T(t0,t1,t2,t3,t4,t5,t6));
-	}
-}
-
-
-#endif 

code/BoostWorkaround/boost/math/common_factor_rt.hpp

@@ -1,37 +0,0 @@
-
-
-#ifndef BOOST_MATH_COMMON_FACTOR_RT_HPP
-#define BOOST_MATH_COMMON_FACTOR_RT_HPP
-
-
-namespace boost	{
-namespace math	{
-
-// TODO: use binary GCD for unsigned integers ....
-template < typename IntegerType >
-IntegerType  gcd( IntegerType a, IntegerType b )
-{
-	const IntegerType zero = (IntegerType)0;
-	while ( true )
-	{
-		if ( a == zero )
-			return b;
-		b %= a;
-
-		if ( b == zero )
-			return a;
-		a %= b;
-	}
-}
-
-template < typename IntegerType >
-IntegerType  lcm( IntegerType a, IntegerType b )
-{
-	const IntegerType t = gcd (a,b);
-	if (!t)return t;
-	return a / t * b;
-}
-
-}}
-
-#endif

code/BoostWorkaround/boost/noncopyable.hpp

@@ -1,36 +0,0 @@
-//  Boost noncopyable.hpp header file  --------------------------------------//
-
-//  (C) Copyright Beman Dawes 1999-2003. 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)
-
-//  See http://www.boost.org/libs/utility for documentation.
-
-#ifndef BOOST_NONCOPYABLE_HPP_INCLUDED
-#define BOOST_NONCOPYABLE_HPP_INCLUDED
-
-namespace boost {
-
-//  Private copy constructor and copy assignment ensure classes derived from
-//  class noncopyable cannot be copied.
-
-//  Contributed by Dave Abrahams
-
-namespace noncopyable_  // protection from unintended ADL
-{
-  class noncopyable
-  {
-   protected:
-      noncopyable() {}
-      ~noncopyable() {}
-   private:  // emphasize the following members are private
-      noncopyable( const noncopyable& );
-      const noncopyable& operator=( const noncopyable& );
-  };
-}
-
-typedef noncopyable_::noncopyable noncopyable;
-
-} // namespace boost
-
-#endif  // BOOST_NONCOPYABLE_HPP_INCLUDED

code/BoostWorkaround/boost/pointer_cast.hpp

@@ -1,45 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2005. 
-// 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)
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifndef BOOST_POINTER_CAST_HPP
-#define BOOST_POINTER_CAST_HPP
-
-namespace boost { 
-
-//static_pointer_cast overload for raw pointers
-template<class T, class U>
-inline T* static_pointer_cast(U *ptr)
-{  
-   return static_cast<T*>(ptr);
-}
-
-//dynamic_pointer_cast overload for raw pointers
-template<class T, class U>
-inline T* dynamic_pointer_cast(U *ptr)
-{  
-   return dynamic_cast<T*>(ptr);
-}
-
-//const_pointer_cast overload for raw pointers
-template<class T, class U>
-inline T* const_pointer_cast(U *ptr)
-{  
-   return const_cast<T*>(ptr);
-}
-
-//reinterpret_pointer_cast overload for raw pointers
-template<class T, class U>
-inline T* reinterpret_pointer_cast(U *ptr)
-{  
-   return reinterpret_cast<T*>(ptr);
-}
-
-} // namespace boost
-
-#endif   //BOOST_POINTER_CAST_HPP

code/BoostWorkaround/boost/scoped_array.hpp

@@ -1,79 +0,0 @@
-
-#ifndef __AI_BOOST_SCOPED_ARRAY_INCLUDED
-#define __AI_BOOST_SCOPED_ARRAY_INCLUDED
-
-#ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED
-
-namespace boost {
-
-// small replacement for boost::scoped_array
-template <class T>
-class scoped_array
-{
-public:
-
-	// provide a default construtctor
-	scoped_array()
-		: ptr(0)
-	{
-	}
-
-	// construction from an existing heap object of type T
-	scoped_array(T* _ptr)
-		: ptr(_ptr)
-	{
-	}
-
-	// automatic destruction of the wrapped object at the
-	// end of our lifetime
-	~scoped_array()
-	{
-		delete[] ptr;
-	}
-
-	inline T* get()
-	{
-		return ptr;
-	}
-
-	inline T* operator-> ()
-	{
-		return ptr;
-	}
-
-	inline void reset (T* t = 0)
-	{
-		delete[] ptr;
-		ptr = t;
-	}
-
-	T & operator[](std::ptrdiff_t i) const
-	{
-		return ptr[i];
-	}
-
-	void swap(scoped_array & b)
-	{
-		std::swap(ptr, b.ptr);
-	}
-
-private:
-
-	// encapsulated object pointer
-	T* ptr;
-
-};
-
-template<class T>
-inline void swap(scoped_array<T> & a, scoped_array<T> & b)
-{
-	a.swap(b);
-}
-
-} // end of namespace boost
-
-#else
-#	error "scoped_array.h was already included"
-#endif
-#endif // __AI_BOOST_SCOPED_ARRAY_INCLUDED
-

code/BoostWorkaround/boost/scoped_ptr.hpp

@@ -1,79 +0,0 @@
-
-#ifndef __AI_BOOST_SCOPED_PTR_INCLUDED
-#define __AI_BOOST_SCOPED_PTR_INCLUDED
-
-#ifndef BOOST_SCOPED_PTR_HPP_INCLUDED
-
-namespace boost {
-
-// small replacement for std::unique_ptr
-template <class T>
-class scoped_ptr
-{
-public:
-
-	// provide a default construtctor
-	scoped_ptr()
-		: ptr(0)
-	{
-	}
-
-	// construction from an existing heap object of type T
-	scoped_ptr(T* _ptr)
-		: ptr(_ptr)
-	{
-	}
-
-	// automatic destruction of the wrapped object at the
-	// end of our lifetime
-	~scoped_ptr()
-	{
-		delete ptr;
-	}
-
-	inline T* get() const
-	{
-		return ptr;
-	}
-
-	inline operator T*()
-	{
-		return ptr;
-	}
-
-	inline T* operator-> ()
-	{
-		return ptr;
-	}
-
-	inline void reset (T* t = 0)
-	{
-		delete ptr;
-		ptr = t;
-	}
-
-	void swap(scoped_ptr & b)
-	{
-		std::swap(ptr, b.ptr);
-	}
-
-private:
-
-	// encapsulated object pointer
-	T* ptr;
-
-};
-
-template<class T>
-inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b)
-{
-	a.swap(b);
-}
-
-} // end of namespace boost
-
-#else
-#	error "scoped_ptr.h was already included"
-#endif
-#endif // __AI_BOOST_SCOPED_PTR_INCLUDED
-

code/BoostWorkaround/boost/shared_array.hpp

@@ -1,228 +0,0 @@
-
-#ifndef INCLUDED_AI_BOOST_SHARED_ARRAY
-#define INCLUDED_AI_BOOST_SHARED_ARRAY
-
-#ifndef BOOST_SHARED_ARRAY_HPP_INCLUDED
-
-// ------------------------------
-// Internal stub
-namespace boost {
-	namespace array_detail {
-		class controller {
-		public:
-
-			controller()
-				: cnt(1)
-			{}
-		
-		public:
-
-			template <typename T>
-			controller* decref(T* pt) {
-				if (--cnt <= 0) {
-					delete this;
-					delete[] pt;
-				}
-				return NULL;
-			}
-		
-			controller* incref() {
-				++cnt;
-				return this;
-			}
-
-			long get() const {
-				return cnt;
-			}
-
-		private:
-			long cnt;
-		};
-
-		struct empty {};
-		
-		template <typename DEST, typename SRC>
-		struct is_convertible_stub {
-			
-			struct yes {char s[1];};
-			struct no  {char s[2];};
-
-			static yes foo(DEST*);
-			static no  foo(...);
-
-			enum {result = (sizeof(foo((SRC*)0)) == sizeof(yes) ? 1 : 0)};	
-		};
-
-		template <bool> struct enable_if {};
-		template <> struct enable_if<true> {
-			typedef empty result;
-		};
-
-		template <typename DEST, typename SRC>
-		struct is_convertible : public enable_if<is_convertible_stub<DEST,SRC>::result > {
-		};
-	}
-
-// ------------------------------
-// Small replacement for boost::shared_array, not threadsafe because no
-// atomic reference counter is in use.
-// ------------------------------
-template <class T>
-class shared_array
-{
-	template <typename TT> friend class shared_array;
-
-	template<class TT> friend bool operator== (const shared_array<TT>& a, const shared_array<TT>& b);
-	template<class TT> friend bool operator!= (const shared_array<TT>& a, const shared_array<TT>& b);
-	template<class TT> friend bool operator<  (const shared_array<TT>& a, const shared_array<TT>& b);
-
-public:
-
-	typedef T element_type;
-
-public:
-
-	// provide a default constructor
-	shared_array()
-		: ptr()
-		, ctr(NULL)
-	{
-	}
-
-	// construction from an existing object of type T
-	explicit shared_array(T* ptr)
-		: ptr(ptr)
-		, ctr(ptr ? new array_detail::controller() : NULL)
-	{
-	}
-
-	shared_array(const shared_array& r)
-		: ptr(r.ptr)
-		, ctr(r.ctr ? r.ctr->incref() : NULL)
-	{
-	}
-
-	template <typename Y>
-	shared_array(const shared_array<Y>& r,typename detail::is_convertible<T,Y>::result = detail::empty())
-		: ptr(r.ptr)
-		, ctr(r.ctr ? r.ctr->incref() : NULL)
-	{
-	}
-
-	// automatic destruction of the wrapped object when all
-	// references are freed.
-	~shared_array()	{
-		if (ctr) {
-			ctr = ctr->decref(ptr);
-		}
-	}
-
-	shared_array& operator=(const shared_array& r) {
-		if (this == &r) {
-			return *this;
-		}
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = r.ptr;
-		ctr = ptr?r.ctr->incref():NULL;
-		return *this;
-	}
-
-	template <typename Y>
-	shared_array& operator=(const shared_array<Y>& r) {
-		if (this == &r) {
-			return *this;
-		}
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = r.ptr;
-		ctr = ptr?r.ctr->incref():NULL;
-		return *this;
-	}
-
-	// pointer access
-	inline operator T*()	{
-		return ptr;
-	}
-
-	inline T* operator-> () const	{
-		return ptr;
-	}
-
-	// standard semantics
-	inline T* get() {
-		return ptr;
-	}
-
-	T& operator[] (std::ptrdiff_t index) const {
-		return ptr[index];
-	}
-
-	inline const T* get() const	{
-		return ptr;
-	}
-
-	inline operator bool () const {
-		return ptr != NULL;
-	}
-
-	inline bool unique() const {
-		return use_count() == 1;
-	}
-
-	inline long use_count() const {
-		return ctr->get();
-	}
-
-	inline void reset (T* t = 0)	{
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = t;
-		ctr = ptr?new array_detail::controller():NULL;
-	}
-
-	void swap(shared_array & b)	{
-		std::swap(ptr, b.ptr);
-		std::swap(ctr, b.ctr);
-	}
-
-
-private:
-
-	// encapsulated object pointer
-	T* ptr;
-
-	// control block
-	array_detail::controller* ctr;
-};
-
-template<class T>
-inline void swap(shared_array<T> & a, shared_array<T> & b)
-{
-	a.swap(b);
-}
-
-template<class T>
-bool operator== (const shared_array<T>& a, const shared_array<T>& b) {
-	return a.ptr == b.ptr;
-}
-template<class T>
-bool operator!= (const shared_array<T>& a, const shared_array<T>& b) {
-	return a.ptr != b.ptr;
-}
-	
-template<class T>
-bool operator< (const shared_array<T>& a, const shared_array<T>& b) {
-	return a.ptr < b.ptr;
-}
-
-
-} // end of namespace boost
-
-#else
-#	error "shared_array.h was already included"
-#endif
-#endif // INCLUDED_AI_BOOST_SHARED_ARRAY

code/BoostWorkaround/boost/shared_ptr.hpp

@@ -1,260 +0,0 @@
-
-#ifndef INCLUDED_AI_BOOST_SHARED_PTR
-#define INCLUDED_AI_BOOST_SHARED_PTR
-
-#ifndef BOOST_SHARED_PTR_HPP_INCLUDED
-
-// ------------------------------
-// Internal stub
-
-#include <stddef.h> //NULL
-#include <algorithm> //std::swap
-namespace boost {
-	namespace detail {
-		class controller {
-		public:
-
-			controller()
-				: cnt(1)
-			{}
-		
-		public:
-
-			template <typename T>
-			controller* decref(T* pt) {
-				if (--cnt <= 0) {
-					delete this;
-					delete pt;
-				}
-				return NULL;
-			}
-		
-			controller* incref() {
-				++cnt;
-				return this;
-			}
-
-			long get() const {
-				return cnt;
-			}
-
-		private:
-			long cnt;
-		};
-
-		struct empty {};
-		
-		template <typename DEST, typename SRC>
-		struct is_convertible_stub {
-			
-			struct yes {char s[1];};
-			struct no  {char s[2];};
-
-			static yes foo(DEST*);
-			static no  foo(...);
-
-			enum {result = (sizeof(foo((SRC*)0)) == sizeof(yes) ? 1 : 0)};	
-		};
-
-		template <bool> struct enable_if {};
-		template <> struct enable_if<true> {
-			typedef empty result;
-		};
-
-		template <typename DEST, typename SRC>
-		struct is_convertible : public enable_if<is_convertible_stub<DEST,SRC>::result > {
-		};
-	}
-
-// ------------------------------
-// Small replacement for std::shared_ptr, not threadsafe because no
-// atomic reference counter is in use.
-// ------------------------------
-template <class T>
-class shared_ptr
-{
-	template <typename TT> friend class shared_ptr;
-
-	template<class TT, class U> friend shared_ptr<TT> static_pointer_cast   (shared_ptr<U> ptr);
-	template<class TT, class U> friend shared_ptr<TT> dynamic_pointer_cast  (shared_ptr<U> ptr);
-	template<class TT, class U> friend shared_ptr<TT> const_pointer_cast    (shared_ptr<U> ptr);
-
-	template<class TT> friend bool operator== (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
-	template<class TT> friend bool operator!= (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
-	template<class TT> friend bool operator<  (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
-
-public:
-
-	typedef T element_type;
-
-public:
-
-	// provide a default constructor
-	shared_ptr()
-		: ptr()
-		, ctr(NULL)
-	{
-	}
-
-	// construction from an existing object of type T
-	explicit shared_ptr(T* ptr)
-		: ptr(ptr)
-		, ctr(ptr ? new detail::controller() : NULL)
-	{
-	}
-
-	shared_ptr(const shared_ptr& r)
-		: ptr(r.ptr)
-		, ctr(r.ctr ? r.ctr->incref() : NULL)
-	{
-	}
-
-	template <typename Y>
-	shared_ptr(const shared_ptr<Y>& r,typename detail::is_convertible<T,Y>::result = detail::empty())
-		: ptr(r.ptr)
-		, ctr(r.ctr ? r.ctr->incref() : NULL)
-	{
-	}
-
-	// automatic destruction of the wrapped object when all
-	// references are freed.
-	~shared_ptr()	{
-		if (ctr) {
-			ctr = ctr->decref(ptr);
-		}
-	}
-
-	shared_ptr& operator=(const shared_ptr& r) {
-		if (this == &r) {
-			return *this;
-		}
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = r.ptr;
-		ctr = ptr?r.ctr->incref():NULL;
-		return *this;
-	}
-
-	template <typename Y>
-	shared_ptr& operator=(const shared_ptr<Y>& r) {
-		if (this == &r) {
-			return *this;
-		}
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = r.ptr;
-		ctr = ptr?r.ctr->incref():NULL;
-		return *this;
-	}
-
-	// pointer access
-	inline operator T*() const {
-		return ptr;
-	}
-
-	inline T* operator-> () const	{
-		return ptr;
-	}
-
-	// standard semantics
-	inline T* get() {
-		return ptr;
-	}
-
-	inline const T* get() const	{
-		return ptr;
-	}
-
-	inline operator bool () const {
-		return ptr != NULL;
-	}
-
-	inline bool unique() const {
-		return use_count() == 1;
-	}
-
-	inline long use_count() const {
-		return ctr->get();
-	}
-
-	inline void reset (T* t = 0)	{
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = t;
-		ctr = ptr?new detail::controller():NULL;
-	}
-
-	void swap(shared_ptr & b)	{
-		std::swap(ptr, b.ptr);
-		std::swap(ctr, b.ctr);
-	}
-
-private:
-
-
-	// for use by the various xxx_pointer_cast helper templates
-	explicit shared_ptr(T* ptr, detail::controller* ctr)
-		: ptr(ptr)
-		, ctr(ctr->incref())
-	{
-	}
-
-private:
-
-	// encapsulated object pointer
-	T* ptr;
-
-	// control block
-	detail::controller* ctr;
-};
-
-template<class T>
-inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
-{
-	a.swap(b);
-}
-
-template<class T>
-bool operator== (const shared_ptr<T>& a, const shared_ptr<T>& b) {
-	return a.ptr == b.ptr;
-}
-template<class T>
-bool operator!= (const shared_ptr<T>& a, const shared_ptr<T>& b) {
-	return a.ptr != b.ptr;
-}
-	
-template<class T>
-bool operator< (const shared_ptr<T>& a, const shared_ptr<T>& b) {
-	return a.ptr < b.ptr;
-}
-
-
-template<class T, class U>
-inline shared_ptr<T> static_pointer_cast( shared_ptr<U> ptr)
-{  
-   return shared_ptr<T>(static_cast<T*>(ptr.ptr),ptr.ctr);
-}
-
-template<class T, class U>
-inline shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> ptr)
-{  
-   return shared_ptr<T>(dynamic_cast<T*>(ptr.ptr),ptr.ctr);
-}
-
-template<class T, class U>
-inline shared_ptr<T> const_pointer_cast( shared_ptr<U> ptr)
-{  
-   return shared_ptr<T>(const_cast<T*>(ptr.ptr),ptr.ctr);
-}
-
-
-
-} // end of namespace boost
-
-#else
-#	error "shared_ptr.h was already included"
-#endif
-#endif // INCLUDED_AI_BOOST_SHARED_PTR

code/BoostWorkaround/boost/static_assert.hpp

@@ -1,20 +0,0 @@
-
-#ifndef AI_BOOST_STATIC_ASSERT_INCLUDED
-#define AI_BOOST_STATIC_ASSERT_INCLUDED
-
-#ifndef BOOST_STATIC_ASSERT
-
-namespace boost {
-	namespace detail {
-
-		template <bool b>  class static_assertion_failure;
-		template <>        class static_assertion_failure<true> {};
-	}
-}
-
-
-#define BOOST_STATIC_ASSERT(eval) \
-{boost::detail::static_assertion_failure<(eval)> assert_dummy;(void)assert_dummy;}
-
-#endif
-#endif // !! AI_BOOST_STATIC_ASSERT_INCLUDED

code/BoostWorkaround/boost/timer.hpp

@@ -1,73 +0,0 @@
-//  boost timer.hpp header file  ---------------------------------------------//
-
-//  Copyright Beman Dawes 1994-99.  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)
-
-//  See http://www.boost.org/libs/timer for documentation.
-
-//  Revision History
-//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)
-//  12 Jan 01  Change to inline implementation to allow use without library
-//             builds. See docs for more rationale. (Beman Dawes) 
-//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
-//  16 Jul 99  Second beta
-//   6 Jul 99  Initial boost version
-
-#ifndef BOOST_TIMER_HPP
-#define BOOST_TIMER_HPP
-
-//#include <boost/config.hpp>
-#include <ctime>
-#include <limits>
-//#include <boost/limits.hpp>
-
-# ifdef BOOST_NO_STDC_NAMESPACE
-    namespace std { using ::clock_t; using ::clock; }
-# endif
-
-
-namespace boost {
-
-//  timer  -------------------------------------------------------------------//
-
-//  A timer object measures elapsed time.
-
-//  It is recommended that implementations measure wall clock rather than CPU
-//  time since the intended use is performance measurement on systems where
-//  total elapsed time is more important than just process or CPU time.
-
-//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
-//  due to implementation limitations.  The accuracy of timings depends on the
-//  accuracy of timing information provided by the underlying platform, and
-//  this varies a great deal from platform to platform.
-
-class timer
-{
- public:
-         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
-//         timer( const timer& src );      // post: elapsed()==src.elapsed()
-//        ~timer(){}
-//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
-  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
-  double elapsed() const                  // return elapsed time in seconds
-    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
-
-  double elapsed_max() const   // return estimated maximum value for elapsed()
-  // Portability warning: elapsed_max() may return too high a value on systems
-  // where std::clock_t overflows or resets at surprising values.
-  {
-    return (double((std::numeric_limits<std::clock_t>::max)())
-       - double(_start_time)) / double(CLOCKS_PER_SEC); 
-  }
-
-  double elapsed_min() const            // return minimum value for elapsed()
-   { return double(1)/double(CLOCKS_PER_SEC); }
-
- private:
-  std::clock_t _start_time;
-}; // timer
-
-} // namespace boost
-
-#endif  // BOOST_TIMER_HPP

code/BoostWorkaround/boost/tuple/tuple.hpp

@@ -1,283 +0,0 @@
-// A very small replacement for boost::tuple
-// (c) Alexander Gessler, 2008 [[email protected]]
-
-#ifndef BOOST_TUPLE_INCLUDED
-#define BOOST_TUPLE_INCLUDED
-
-namespace boost	{
-	namespace detail	{
-
-		// Represents an empty tuple slot (up to 5 supported)
-		struct nulltype {};
-
-		// For readable error messages
-		struct tuple_component_idx_out_of_bounds;
-
-		// To share some code for the const/nonconst versions of the getters
-		template <bool b, typename T>
-		struct ConstIf {
-			typedef T t;
-		};
-
-		template <typename T>
-		struct ConstIf<true,T> {
-			typedef const T t;
-		};
-
-		// Predeclare some stuff
-		template <typename, unsigned, typename, bool, unsigned> struct value_getter;
-
-		// Helper to obtain the type of a tuple element
-		template <typename T, unsigned NIDX, typename TNEXT, unsigned N /*= 0*/>
-		struct type_getter	{
-			typedef type_getter<typename TNEXT::type,NIDX+1,typename TNEXT::next_type,N> next_elem_getter;
-			typedef typename next_elem_getter::type type;
-		};
-
-		template <typename T, unsigned NIDX, typename TNEXT >
-		struct type_getter <T,NIDX,TNEXT,NIDX>	{
-			typedef T type;
-		};
-
-		// Base class for all explicit specializations of list_elem
-		template <typename T, unsigned NIDX, typename TNEXT >
-		struct list_elem_base {
-
-			// Store template parameters
-			typedef TNEXT next_type;
-			typedef T type;
-
-			static const unsigned nidx = NIDX;
-		};
-
-		// Represents an element in the tuple component list
-		template <typename T, unsigned NIDX, typename TNEXT >
-		struct list_elem : list_elem_base<T,NIDX,TNEXT>{
-
-			// Real members
-			T me;
-			TNEXT next;
-
-			// Get the value of a specific tuple element
-			template <unsigned N>
-			typename type_getter<T,NIDX,TNEXT,N>::type& get () {
-				value_getter <T,NIDX,TNEXT,false,N> s;
-				return s(*this);
-			}
-
-			// Get the value of a specific tuple element
-			template <unsigned N>
-			const typename type_getter<T,NIDX,TNEXT,N>::type& get () const {
-				value_getter <T,NIDX,TNEXT,true,N> s;
-				return s(*this);
-			}
-
-			// Explicit cast
-			template <typename T2, typename TNEXT2 >
-			operator list_elem<T2,NIDX,TNEXT2> () const	{
-				list_elem<T2,NIDX,TNEXT2> ret;
-				ret.me   = (T2)me;
-				ret.next = next;
-				return ret;
-			}
-
-			// Recursively compare two elements (last element returns always true)
-			bool operator == (const list_elem& s) const	{
-				return (me == s.me && next == s.next);
-			}
-		};
-
-		// Represents a non-used tuple element - the very last element processed
-		template <typename TNEXT, unsigned NIDX  >
-		struct list_elem<nulltype,NIDX,TNEXT> : list_elem_base<nulltype,NIDX,TNEXT> {
-			template <unsigned N, bool IS_CONST = true> struct value_getter		{
-				/* just dummy members to produce readable error messages */
-				tuple_component_idx_out_of_bounds operator () (typename ConstIf<IS_CONST,list_elem>::t& me);
-			};
-			template <unsigned N> struct type_getter  {
-				/* just dummy members to produce readable error messages */
-				typedef tuple_component_idx_out_of_bounds type;
-			};
-
-			// dummy
-			list_elem& operator = (const list_elem& /*other*/)	{
-				return *this;
-			}
-
-			// dummy
-			bool operator == (const list_elem& other)	{
-				return true;
-			}
-		};
-
-		// Represents the absolute end of the list
-		typedef list_elem<nulltype,0,int> list_end;
-
-		// Helper obtain to query the value of a tuple element
-		// NOTE: This can't be a nested class as the compiler won't accept a full or
-		// partial specialization of a nested class of a non-specialized template
-		template <typename T, unsigned NIDX, typename TNEXT, bool IS_CONST, unsigned N>
-		struct value_getter	 {
-
-			// calling list_elem
-			typedef list_elem<T,NIDX,TNEXT> outer_elem;
-
-			// typedef for the getter for next element
-			typedef value_getter<typename TNEXT::type,NIDX+1,typename TNEXT::next_type,
-				IS_CONST, N> next_value_getter;
-
-			typename ConstIf<IS_CONST,typename type_getter<T,NIDX,TNEXT,N>::type>::t&
-				operator () (typename ConstIf<IS_CONST,outer_elem >::t& me) {
-
-				next_value_getter s;
-				return s(me.next);
-			}
-		};
-
-		template <typename T, unsigned NIDX, typename TNEXT, bool IS_CONST>
-		struct value_getter <T,NIDX,TNEXT,IS_CONST,NIDX>	{
-			typedef list_elem<T,NIDX,TNEXT> outer_elem;
-
-			typename ConstIf<IS_CONST,T>::t& operator () (typename ConstIf<IS_CONST,outer_elem >::t& me) {
-				return me.me;
-			}
-		};
-	}
-
-	// A very minimal implementation for up to 5 elements
-	template <typename T0  = detail::nulltype,
-		      typename T1  = detail::nulltype,
-			  typename T2  = detail::nulltype,
-			  typename T3  = detail::nulltype,
-			  typename T4  = detail::nulltype>
-	class tuple	{
-
-		template <typename T0b,
-		      typename T1b,
-			  typename T2b,
-			  typename T3b,
-			  typename T4b >
-		friend class tuple;
-
-	private:
-
-		typedef detail::list_elem<T0,0,
-					detail::list_elem<T1,1,
-						detail::list_elem<T2,2,
-							detail::list_elem<T3,3,
-								detail::list_elem<T4,4,
-									detail::list_end > > > > > very_long;
-
-		very_long m;
-
-	public:
-
-		// Get a specific tuple element
-		template <unsigned N>
-		typename detail::type_getter<T0,0,typename very_long::next_type, N>::type& get ()	{
-			return m.template get<N>();
-		}
-
-		// ... and the const version
-		template <unsigned N>
-		const typename detail::type_getter<T0,0,typename very_long::next_type, N>::type& get () const	{
-			return m.template get<N>();
-		}
-
-
-		// comparison operators
-		bool operator== (const tuple& other) const	{
-			return m == other.m;
-		}
-
-		// ... and the other way round
-		bool operator!= (const tuple& other) const	{
-			return !(m == other.m);
-		}
-
-		// cast to another tuple - all single elements must be convertible
-		template <typename T0b, typename T1b,typename T2b,typename T3b, typename T4b>
-		operator tuple <T0b,T1b,T2b,T3b,T4b> () const {
-			tuple <T0b,T1b,T2b,T3b,T4b> s;
-			s.m = (typename tuple <T0b,T1b,T2b,T3b,T4b>::very_long)m;
-			return s;
-		}
-	};
-
-	// Another way to access an element ...
-	template <unsigned N,typename T0,typename T1,typename T2,typename T3,typename T4>
-	inline typename tuple<T0,T1,T2,T3,T4>::very_long::template type_getter<N>::type& get (
-			tuple<T0,T1,T2,T3,T4>& m)	{
-			return m.template get<N>();
-		}
-
-	// ... and the const version
-	template <unsigned N,typename T0,typename T1,typename T2,typename T3,typename T4>
-	inline const typename tuple<T0,T1,T2,T3,T4>::very_long::template type_getter<N>::type& get (
-			const tuple<T0,T1,T2,T3,T4>& m)	{
-			return m.template get<N>();
-		}
-
-	// Constructs a tuple with 5 elements
-	template <typename T0,typename T1,typename T2,typename T3,typename T4>
-	inline tuple <T0,T1,T2,T3,T4> make_tuple (const T0& t0,
-		const T1& t1,const T2& t2,const T3& t3,const T4& t4) {
-
-		tuple <T0,T1,T2,T3,T4> t;
-		t.template get<0>() = t0;
-		t.template get<1>() = t1;
-		t.template get<2>() = t2;
-		t.template get<3>() = t3;
-		t.template get<4>() = t4;
-		return t;
-	}
-
-	// Constructs a tuple with 4 elements
-	template <typename T0,typename T1,typename T2,typename T3>
-	inline tuple <T0,T1,T2,T3> make_tuple (const T0& t0,
-		const T1& t1,const T2& t2,const T3& t3) {
-		tuple <T0,T1,T2,T3> t;
-		t.template get<0>() = t0;
-		t.template get<1>() = t1;
-		t.template get<2>() = t2;
-		t.template get<3>() = t3;
-		return t;
-	}
-
-	// Constructs a tuple with 3 elements
-	template <typename T0,typename T1,typename T2>
-	inline tuple <T0,T1,T2> make_tuple (const T0& t0,
-		const T1& t1,const T2& t2) {
-		tuple <T0,T1,T2> t;
-		t.template get<0>() = t0;
-		t.template get<1>() = t1;
-		t.template get<2>() = t2;
-		return t;
-	}
-
-	// Constructs a tuple with 2 elements 
-	template <typename T0,typename T1>
-	inline tuple <T0,T1> make_tuple (const T0& t0,
-		const T1& t1) {
-		tuple <T0,T1> t;
-		t.template get<0>() = t0;
-		t.template get<1>() = t1;
-		return t;
-	}
-
-	// Constructs a tuple with 1 elements (well ...)
-	template <typename T0>
-	inline tuple <T0> make_tuple (const T0& t0) {
-		tuple <T0> t;
-		t.template get<0>() = t0;
-		return t;
-	}
-
-	// Constructs a tuple with 0 elements (well ...)
-	inline tuple <> make_tuple () {
-		tuple <> t;
-		return t;
-	}
-}
-
-#endif // !! BOOST_TUPLE_INCLUDED

code/CMakeLists.txt

@@ -61,20 +61,6 @@ SET( Core_SRCS
   Assimp.cpp
 )
 
-SET( Boost_SRCS
-  BoostWorkaround/boost/math/common_factor_rt.hpp
-  BoostWorkaround/boost/foreach.hpp
-  BoostWorkaround/boost/format.hpp
-  BoostWorkaround/boost/scoped_array.hpp
-  BoostWorkaround/boost/scoped_ptr.hpp
-  BoostWorkaround/boost/shared_array.hpp
-  BoostWorkaround/boost/shared_ptr.hpp
-  BoostWorkaround/boost/make_shared.hpp
-  BoostWorkaround/boost/static_assert.hpp
-  BoostWorkaround/boost/tuple/tuple.hpp
-)
-SOURCE_GROUP(Boost FILES ${Boost_SRCS})
-
 SET( Logging_SRCS
   ${HEADER_PATH}/DefaultLogger.hpp
   ${HEADER_PATH}/LogStream.hpp
@@ -711,7 +697,6 @@ SET( assimp_src
   ${Clipper_SRCS}
   ${openddl_parser_SRCS}
   # Necessary to show the headers in the project when using the VC++ generator:
-  ${Boost_SRCS}
 
   ${PUBLIC_HEADERS}
   ${COMPILER_HEADERS}

test/CMakeLists.txt

@@ -42,7 +42,6 @@ SET( TEST_SRCS
   unit/utTextureTransform.cpp
   unit/utTriangulate.cpp
   unit/utVertexTriangleAdjacency.cpp
-  unit/utNoBoostTest.cpp
   unit/utColladaExportCamera.cpp
   unit/utColladaExportLight.cpp
   unit/utIssues.cpp