C++11-Support: remove boost.
Kim Kulling
parent
632b58f27e
commit
6b243230b2
|
|
@ -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.
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
@ -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
|
|
||||||
|
|
@ -1,283 +0,0 @@
|
||||||
// A very small replacement for boost::tuple
|
|
||||||
// (c) Alexander Gessler, 2008 [alexander.gessler@gmx.net]
|
|
||||||
|
|
||||||
#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
|
|
||||||
|
|
@ -61,20 +61,6 @@ SET( Core_SRCS
|
||||||
Assimp.cpp
|
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
|
SET( Logging_SRCS
|
||||||
${HEADER_PATH}/DefaultLogger.hpp
|
${HEADER_PATH}/DefaultLogger.hpp
|
||||||
${HEADER_PATH}/LogStream.hpp
|
${HEADER_PATH}/LogStream.hpp
|
||||||
|
|
@ -711,7 +697,6 @@ SET( assimp_src
|
||||||
${Clipper_SRCS}
|
${Clipper_SRCS}
|
||||||
${openddl_parser_SRCS}
|
${openddl_parser_SRCS}
|
||||||
# Necessary to show the headers in the project when using the VC++ generator:
|
# Necessary to show the headers in the project when using the VC++ generator:
|
||||||
${Boost_SRCS}
|
|
||||||
|
|
||||||
${PUBLIC_HEADERS}
|
${PUBLIC_HEADERS}
|
||||||
${COMPILER_HEADERS}
|
${COMPILER_HEADERS}
|
||||||
|
|
|
||||||
|
|
@ -42,7 +42,6 @@ SET( TEST_SRCS
|
||||||
unit/utTextureTransform.cpp
|
unit/utTextureTransform.cpp
|
||||||
unit/utTriangulate.cpp
|
unit/utTriangulate.cpp
|
||||||
unit/utVertexTriangleAdjacency.cpp
|
unit/utVertexTriangleAdjacency.cpp
|
||||||
unit/utNoBoostTest.cpp
|
|
||||||
unit/utColladaExportCamera.cpp
|
unit/utColladaExportCamera.cpp
|
||||||
unit/utColladaExportLight.cpp
|
unit/utColladaExportLight.cpp
|
||||||
unit/utIssues.cpp
|
unit/utIssues.cpp
|
||||||
|
|
|
||||||
Loading…
Reference in New Issue