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
|
||||
)
|
||||
|
||||
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}
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue