*** empty log message ***
git-svn-id: svn://svn.code.sf.net/p/loki-lib/code/trunk@85 7ec92016-0320-0410-acc4-a06ded1c099a
This commit is contained in:
tslettebo
parent
90a16ecbd4
commit
6539637357
11 changed files with 0 additions and 2899 deletions
|
|
@ -1,335 +0,0 @@
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// The Loki Library
|
|
||||||
// Copyright (c) 2001 by Andrei Alexandrescu
|
|
||||||
// This code accompanies the book:
|
|
||||||
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
|
|
||||||
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
|
|
||||||
// Permission to use, copy, modify, distribute and sell this software for any
|
|
||||||
// purpose is hereby granted without fee, provided that the above copyright
|
|
||||||
// notice appear in all copies and that both that copyright notice and this
|
|
||||||
// permission notice appear in supporting documentation.
|
|
||||||
// The author or Addison-Wesley Longman make no representations about the
|
|
||||||
// suitability of this software for any purpose. It is provided "as is"
|
|
||||||
// without express or implied warranty.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#ifndef ASSOCVECTOR_INC_
|
|
||||||
#define ASSOCVECTOR_INC_
|
|
||||||
|
|
||||||
#include <algorithm>
|
|
||||||
#include <functional>
|
|
||||||
#include <vector>
|
|
||||||
#include <utility>
|
|
||||||
|
|
||||||
namespace Loki
|
|
||||||
{
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template AssocVectorCompare
|
|
||||||
// Used by AssocVector
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
namespace Private
|
|
||||||
{
|
|
||||||
template <class Value, class C>
|
|
||||||
class AssocVectorCompare : public C
|
|
||||||
{
|
|
||||||
typedef std::pair<typename C::first_argument_type, Value>
|
|
||||||
Data;
|
|
||||||
typedef typename C::first_argument_type first_argument_type;
|
|
||||||
|
|
||||||
public:
|
|
||||||
AssocVectorCompare()
|
|
||||||
{}
|
|
||||||
|
|
||||||
AssocVectorCompare(const C& src) : C(src)
|
|
||||||
{}
|
|
||||||
|
|
||||||
bool operator()(const first_argument_type& lhs,
|
|
||||||
const first_argument_type& rhs) const
|
|
||||||
{ return C::operator()(lhs, rhs); }
|
|
||||||
|
|
||||||
bool operator()(const Data& lhs, const Data& rhs) const
|
|
||||||
{ return operator()(lhs.first, rhs.first); }
|
|
||||||
|
|
||||||
bool operator()(const Data& lhs,
|
|
||||||
const first_argument_type& rhs) const
|
|
||||||
{ return operator()(lhs.first, rhs); }
|
|
||||||
|
|
||||||
bool operator()(const first_argument_type& lhs,
|
|
||||||
const Data& rhs) const
|
|
||||||
{ return operator()(lhs, rhs.first); }
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template AssocVector
|
|
||||||
// An associative vector built as a syntactic drop-in replacement for std::map
|
|
||||||
// BEWARE: AssocVector doesn't respect all map's guarantees, the most important
|
|
||||||
// being:
|
|
||||||
// * iterators are invalidated by insert and erase operations
|
|
||||||
// * the complexity of insert/erase is O(N) not O(log N)
|
|
||||||
// * value_type is std::pair<K, V> not std::pair<const K, V>
|
|
||||||
// * iterators are random
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template
|
|
||||||
<
|
|
||||||
class K,
|
|
||||||
class V,
|
|
||||||
class C = std::less<K>,
|
|
||||||
class A = std::allocator< std::pair<K, V> >
|
|
||||||
>
|
|
||||||
class AssocVector
|
|
||||||
: private std::vector< std::pair<K, V>, A >
|
|
||||||
, private Private::AssocVectorCompare<V, C>
|
|
||||||
{
|
|
||||||
typedef std::vector<std::pair<K, V>, A> Base;
|
|
||||||
typedef Private::AssocVectorCompare<V, C> MyCompare;
|
|
||||||
|
|
||||||
public:
|
|
||||||
typedef K key_type;
|
|
||||||
typedef V mapped_type;
|
|
||||||
typedef typename Base::value_type value_type;
|
|
||||||
|
|
||||||
typedef C key_compare;
|
|
||||||
typedef A allocator_type;
|
|
||||||
typedef typename A::reference reference;
|
|
||||||
typedef typename A::const_reference const_reference;
|
|
||||||
typedef typename Base::iterator iterator;
|
|
||||||
typedef typename Base::const_iterator const_iterator;
|
|
||||||
typedef typename Base::size_type size_type;
|
|
||||||
typedef typename Base::difference_type difference_type;
|
|
||||||
typedef typename A::pointer pointer;
|
|
||||||
typedef typename A::const_pointer const_pointer;
|
|
||||||
typedef typename Base::reverse_iterator reverse_iterator;
|
|
||||||
typedef typename Base::const_reverse_iterator const_reverse_iterator;
|
|
||||||
|
|
||||||
class value_compare
|
|
||||||
: public std::binary_function<value_type, value_type, bool>
|
|
||||||
, private key_compare
|
|
||||||
{
|
|
||||||
friend class AssocVector;
|
|
||||||
|
|
||||||
protected:
|
|
||||||
value_compare(key_compare pred) : key_compare(pred)
|
|
||||||
{}
|
|
||||||
|
|
||||||
public:
|
|
||||||
bool operator()(const value_type& lhs, const value_type& rhs) const
|
|
||||||
{ return key_compare::operator()(lhs.first, rhs.first); }
|
|
||||||
};
|
|
||||||
|
|
||||||
// 23.3.1.1 construct/copy/destroy
|
|
||||||
|
|
||||||
explicit AssocVector(const key_compare& comp = key_compare(),
|
|
||||||
const A& alloc = A())
|
|
||||||
: Base(alloc), MyCompare(comp)
|
|
||||||
{}
|
|
||||||
|
|
||||||
template <class InputIterator>
|
|
||||||
AssocVector(InputIterator first, InputIterator last,
|
|
||||||
const key_compare& comp = key_compare(),
|
|
||||||
const A& alloc = A())
|
|
||||||
: Base(first, last, alloc), MyCompare(comp)
|
|
||||||
{
|
|
||||||
MyCompare& me = *this;
|
|
||||||
std::sort(begin(), end(), me);
|
|
||||||
}
|
|
||||||
|
|
||||||
AssocVector& operator=(const AssocVector& rhs)
|
|
||||||
{
|
|
||||||
AssocVector(rhs).swap(*this);
|
|
||||||
return *this;
|
|
||||||
}
|
|
||||||
|
|
||||||
// iterators:
|
|
||||||
// The following are here because MWCW gets 'using' wrong
|
|
||||||
iterator begin() { return Base::begin(); }
|
|
||||||
const_iterator begin() const { return Base::begin(); }
|
|
||||||
iterator end() { return Base::end(); }
|
|
||||||
const_iterator end() const { return Base::end(); }
|
|
||||||
reverse_iterator rbegin() { return Base::rbegin(); }
|
|
||||||
const_reverse_iterator rbegin() const { return Base::rbegin(); }
|
|
||||||
reverse_iterator rend() { return Base::rend(); }
|
|
||||||
const_reverse_iterator rend() const { return Base::rend(); }
|
|
||||||
|
|
||||||
// capacity:
|
|
||||||
bool empty() const { return Base::empty(); }
|
|
||||||
size_type size() const { return Base::size(); }
|
|
||||||
size_type max_size() { return Base::max_size(); }
|
|
||||||
|
|
||||||
// 23.3.1.2 element access:
|
|
||||||
mapped_type& operator[](const key_type& key)
|
|
||||||
{ return insert(value_type(key, mapped_type())).first->second; }
|
|
||||||
|
|
||||||
// modifiers:
|
|
||||||
std::pair<iterator, bool> insert(const value_type& val)
|
|
||||||
{
|
|
||||||
bool found(true);
|
|
||||||
iterator i(lower_bound(val.first));
|
|
||||||
|
|
||||||
if (i == end() || operator()(val.first, i->first))
|
|
||||||
{
|
|
||||||
i = Base::insert(i, val);
|
|
||||||
found = false;
|
|
||||||
}
|
|
||||||
return std::make_pair(i, !found);
|
|
||||||
}
|
|
||||||
|
|
||||||
iterator insert(iterator pos, const value_type& val)
|
|
||||||
{
|
|
||||||
if (pos != end() && operator()(*pos, val) &&
|
|
||||||
(pos == end() - 1 ||
|
|
||||||
!operator()(val, pos[1]) &&
|
|
||||||
operator()(pos[1], val)))
|
|
||||||
{
|
|
||||||
return Base::insert(pos, val);
|
|
||||||
}
|
|
||||||
return insert(val).first;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class InputIterator>
|
|
||||||
void insert(InputIterator first, InputIterator last)
|
|
||||||
{ for (; first != last; ++first) insert(*first); }
|
|
||||||
|
|
||||||
void erase(iterator pos)
|
|
||||||
{ Base::erase(pos); }
|
|
||||||
|
|
||||||
size_type erase(const key_type& k)
|
|
||||||
{
|
|
||||||
iterator i(find(k));
|
|
||||||
if (i == end()) return 0;
|
|
||||||
erase(i);
|
|
||||||
return 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
void erase(iterator first, iterator last)
|
|
||||||
{ Base::erase(first, last); }
|
|
||||||
|
|
||||||
void swap(AssocVector& other)
|
|
||||||
{
|
|
||||||
using std::swap;
|
|
||||||
Base::swap(other);
|
|
||||||
MyCompare& me = *this;
|
|
||||||
MyCompare& rhs = other;
|
|
||||||
swap(me, rhs);
|
|
||||||
}
|
|
||||||
|
|
||||||
void clear()
|
|
||||||
{ Base::clear(); }
|
|
||||||
|
|
||||||
// observers:
|
|
||||||
key_compare key_comp() const
|
|
||||||
{ return *this; }
|
|
||||||
|
|
||||||
value_compare value_comp() const
|
|
||||||
{
|
|
||||||
const key_compare& comp = *this;
|
|
||||||
return value_compare(comp);
|
|
||||||
}
|
|
||||||
|
|
||||||
// 23.3.1.3 map operations:
|
|
||||||
iterator find(const key_type& k)
|
|
||||||
{
|
|
||||||
iterator i(lower_bound(k));
|
|
||||||
if (i != end() && operator()(k, i->first))
|
|
||||||
{
|
|
||||||
i = end();
|
|
||||||
}
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
|
|
||||||
const_iterator find(const key_type& k) const
|
|
||||||
{
|
|
||||||
const_iterator i(lower_bound(k));
|
|
||||||
if (i != end() && operator()(k, i->first))
|
|
||||||
{
|
|
||||||
i = end();
|
|
||||||
}
|
|
||||||
return i;
|
|
||||||
}
|
|
||||||
|
|
||||||
size_type count(const key_type& k) const
|
|
||||||
{ return find(k) != end(); }
|
|
||||||
|
|
||||||
iterator lower_bound(const key_type& k)
|
|
||||||
{
|
|
||||||
MyCompare& me = *this;
|
|
||||||
return std::lower_bound(begin(), end(), k, me);
|
|
||||||
}
|
|
||||||
|
|
||||||
const_iterator lower_bound(const key_type& k) const
|
|
||||||
{
|
|
||||||
const MyCompare& me = *this;
|
|
||||||
return std::lower_bound(begin(), end(), k, me);
|
|
||||||
}
|
|
||||||
|
|
||||||
iterator upper_bound(const key_type& k)
|
|
||||||
{
|
|
||||||
MyCompare& me = *this;
|
|
||||||
return std::upper_bound(begin(), end(), k, me);
|
|
||||||
}
|
|
||||||
|
|
||||||
const_iterator upper_bound(const key_type& k) const
|
|
||||||
{
|
|
||||||
const MyCompare& me = *this;
|
|
||||||
return std::upper_bound(begin(), end(), k, me);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::pair<iterator, iterator> equal_range(const key_type& k)
|
|
||||||
{
|
|
||||||
MyCompare& me = *this;
|
|
||||||
return std::equal_range(begin(), end(), k, me);
|
|
||||||
}
|
|
||||||
|
|
||||||
std::pair<const_iterator, const_iterator> equal_range(
|
|
||||||
const key_type& k) const
|
|
||||||
{
|
|
||||||
const MyCompare& me = *this;
|
|
||||||
return std::equal_range(begin(), end(), k, me);
|
|
||||||
}
|
|
||||||
|
|
||||||
friend bool operator==(const AssocVector& lhs, const AssocVector& rhs)
|
|
||||||
{
|
|
||||||
const Base& me = lhs;
|
|
||||||
return me == rhs;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool operator<(const AssocVector& rhs) const
|
|
||||||
{
|
|
||||||
const Base& me = *this;
|
|
||||||
const Base& yo = rhs;
|
|
||||||
return me < yo;
|
|
||||||
}
|
|
||||||
|
|
||||||
friend bool operator!=(const AssocVector& lhs, const AssocVector& rhs)
|
|
||||||
{ return !(lhs == rhs); }
|
|
||||||
|
|
||||||
friend bool operator>(const AssocVector& lhs, const AssocVector& rhs)
|
|
||||||
{ return rhs < lhs; }
|
|
||||||
|
|
||||||
friend bool operator>=(const AssocVector& lhs, const AssocVector& rhs)
|
|
||||||
{ return !(lhs < rhs); }
|
|
||||||
|
|
||||||
friend bool operator<=(const AssocVector& lhs, const AssocVector& rhs)
|
|
||||||
{ return !(rhs < lhs); }
|
|
||||||
};
|
|
||||||
|
|
||||||
// specialized algorithms:
|
|
||||||
template <class K, class V, class C, class A>
|
|
||||||
void swap(AssocVector<K, V, C, A>& lhs, AssocVector<K, V, C, A>& rhs)
|
|
||||||
{ lhs.swap(rhs); }
|
|
||||||
|
|
||||||
} // namespace Loki
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Change log:
|
|
||||||
// May 20, 2001: change operator= - credit due to Cristoph Koegl
|
|
||||||
// June 11, 2001: remove paren in equal_range - credit due to Cristoph Koegl
|
|
||||||
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
||||||
// January 22, 2002: fixed operator= - credit due to Tom Hyer
|
|
||||||
// June 25, 2002: fixed template insert() - credit due to Robert Minsk
|
|
||||||
// June 27, 2002: fixed member swap() - credit due to David Brookman
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#endif // ASSOCVECTOR_INC_
|
|
||||||
|
|
@ -1,37 +0,0 @@
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// The Loki Library
|
|
||||||
// Copyright (c) 2001 by Andrei Alexandrescu
|
|
||||||
// This code accompanies the book:
|
|
||||||
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
|
|
||||||
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
|
|
||||||
// Permission to use, copy, modify, distribute and sell this software for any
|
|
||||||
// purpose is hereby granted without fee, provided that the above copyright
|
|
||||||
// notice appear in all copies and that both that copyright notice and this
|
|
||||||
// permission notice appear in supporting documentation.
|
|
||||||
// The author or Addison-Wesley Longman make no representations about the
|
|
||||||
// suitability of this software for any purpose. It is provided "as is"
|
|
||||||
// without express or implied warranty.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
// Last update: June 20, 2001
|
|
||||||
|
|
||||||
#ifndef EMPTYTYPE_INC_
|
|
||||||
#define EMPTYTYPE_INC_
|
|
||||||
|
|
||||||
namespace Loki
|
|
||||||
{
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class EmptyType
|
|
||||||
// Used as a class type that doesn't hold anything
|
|
||||||
// Useful as a strawman class
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
class EmptyType {};
|
|
||||||
}
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Change log:
|
|
||||||
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#endif // EMPTYTYPE_INC_
|
|
||||||
|
|
@ -1,153 +0,0 @@
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// The Loki Library
|
|
||||||
// Copyright (c) 2001 by Andrei Alexandrescu
|
|
||||||
// This code accompanies the book:
|
|
||||||
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
|
|
||||||
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
|
|
||||||
// Permission to use, copy, modify, distribute and sell this software for any
|
|
||||||
// purpose is hereby granted without fee, provided that the above copyright
|
|
||||||
// notice appear in all copies and that both that copyright notice and this
|
|
||||||
// permission notice appear in supporting documentation.
|
|
||||||
// The author or Addison-Wesley Longman make no representations about the
|
|
||||||
// suitability of this software for any purpose. It is provided "as is"
|
|
||||||
// without express or implied warranty.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
// Last update: October 12, 2002
|
|
||||||
|
|
||||||
#ifndef FACTORY_INC_
|
|
||||||
#define FACTORY_INC_
|
|
||||||
|
|
||||||
#include "TypeInfo.h"
|
|
||||||
#include "AssocVector.h"
|
|
||||||
#include <exception>
|
|
||||||
|
|
||||||
namespace Loki
|
|
||||||
{
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class DefaultFactoryError
|
|
||||||
// Manages the "Unknown Type" error in an object factory
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
struct DefaultFactoryError
|
|
||||||
{
|
|
||||||
|
|
||||||
struct Exception : public std::exception
|
|
||||||
{
|
|
||||||
const char* what() const throw() { return "Unknown Type"; }
|
|
||||||
};
|
|
||||||
|
|
||||||
template <typename IdentifierType, class AbstractProduct>
|
|
||||||
static AbstractProduct* OnUnknownType(IdentifierType,AbstractProduct *)
|
|
||||||
{
|
|
||||||
throw Exception();
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Factory
|
|
||||||
// Implements a generic object factory
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template
|
|
||||||
<
|
|
||||||
class AbstractProduct,
|
|
||||||
typename IdentifierType,
|
|
||||||
typename ProductCreator = AbstractProduct* (*)(),
|
|
||||||
class FactoryErrorPolicy = DefaultFactoryError
|
|
||||||
>
|
|
||||||
class Factory
|
|
||||||
: public FactoryErrorPolicy
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
bool Register(const IdentifierType& id, ProductCreator creator)
|
|
||||||
{
|
|
||||||
return associations_.insert(
|
|
||||||
IdToProductMap::value_type(id, creator)).second;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool Unregister(const IdentifierType& id)
|
|
||||||
{
|
|
||||||
return associations_.erase(id) == 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
AbstractProduct* CreateObject(const IdentifierType& id)
|
|
||||||
{
|
|
||||||
typename IdToProductMap::iterator i = associations_.find(id);
|
|
||||||
if (i != associations_.end())
|
|
||||||
{
|
|
||||||
return (i->second)();
|
|
||||||
}
|
|
||||||
|
|
||||||
AbstractProduct *dummy;
|
|
||||||
|
|
||||||
return OnUnknownType(id,dummy);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
typedef AssocVector<IdentifierType, ProductCreator> IdToProductMap;
|
|
||||||
IdToProductMap associations_;
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template CloneFactory
|
|
||||||
// Implements a generic cloning factory
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template
|
|
||||||
<
|
|
||||||
class AbstractProduct,
|
|
||||||
class ProductCreator =
|
|
||||||
AbstractProduct* (*)(const AbstractProduct*),
|
|
||||||
typename FactoryErrorPolicy = DefaultFactoryError
|
|
||||||
>
|
|
||||||
class CloneFactory
|
|
||||||
: public FactoryErrorPolicy
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
bool Register(const TypeInfo& ti, ProductCreator creator)
|
|
||||||
{
|
|
||||||
return associations_.insert(
|
|
||||||
IdToProductMap::value_type(ti, creator)).second;
|
|
||||||
}
|
|
||||||
|
|
||||||
bool Unregister(const TypeInfo& id)
|
|
||||||
{
|
|
||||||
return associations_.erase(id) == 1;
|
|
||||||
}
|
|
||||||
|
|
||||||
AbstractProduct* CreateObject(const AbstractProduct* model)
|
|
||||||
{
|
|
||||||
if (model == 0) return 0;
|
|
||||||
|
|
||||||
typename IdToProductMap::iterator i =
|
|
||||||
associations_.find(typeid(*model));
|
|
||||||
if (i != associations_.end())
|
|
||||||
{
|
|
||||||
return (i->second)(model);
|
|
||||||
}
|
|
||||||
|
|
||||||
AbstractProduct *dummy;
|
|
||||||
|
|
||||||
return OnUnknownType(TypeInfo(typeid(*model)),dummy);
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
typedef AssocVector<TypeInfo, ProductCreator> IdToProductMap;
|
|
||||||
IdToProductMap associations_;
|
|
||||||
};
|
|
||||||
} // namespace Loki
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Change log:
|
|
||||||
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
||||||
// May 08, 2002: replaced const_iterator with iterator so that self-modifying
|
|
||||||
// ProductCreators are supported. Also, added a throw() spec to what().
|
|
||||||
// Credit due to Jason Fischl.
|
|
||||||
// October 12, 2002: Ported to MSVC 6 by Terje Slettebø. Interface for Factory
|
|
||||||
// and CloneFactory changed from using template template parameter,
|
|
||||||
// to using class with member template, for the FactoryErrorPolicy.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#endif // FACTORY_INC_
|
|
||||||
|
|
@ -1,39 +0,0 @@
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// The Loki Library
|
|
||||||
// Copyright (c) 2001 by Andrei Alexandrescu
|
|
||||||
// This code accompanies the book:
|
|
||||||
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
|
|
||||||
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
|
|
||||||
// Permission to use, copy, modify, distribute and sell this software for any
|
|
||||||
// purpose is hereby granted without fee, provided that the above copyright
|
|
||||||
// notice appear in all copies and that both that copyright notice and this
|
|
||||||
// permission notice appear in supporting documentation.
|
|
||||||
// The author or Addison-Wesley Longman make no representations about the
|
|
||||||
// suitability of this software for any purpose. It is provided "as is"
|
|
||||||
// without express or implied warranty.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
// Last update: November 22, 2001
|
|
||||||
|
|
||||||
#ifndef NULLTYPE_INC_
|
|
||||||
#define NULLTYPE_INC_
|
|
||||||
|
|
||||||
namespace Loki
|
|
||||||
{
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class NullType
|
|
||||||
// Used as a placeholder for "no type here"
|
|
||||||
// Useful as an end marker in typelists
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
class NullType {};
|
|
||||||
|
|
||||||
} // namespace Loki
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Change log:
|
|
||||||
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
||||||
// November 22, 2001: minor change to support porting to boost
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#endif // NULLTYPE_INC_
|
|
||||||
|
|
@ -1,53 +0,0 @@
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// The Loki Library
|
|
||||||
// Copyright (c) 2001 by Andrei Alexandrescu
|
|
||||||
// This code accompanies the book:
|
|
||||||
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
|
|
||||||
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
|
|
||||||
// Permission to use, copy, modify, distribute and sell this software for any
|
|
||||||
// purpose is hereby granted without fee, provided that the above copyright
|
|
||||||
// notice appear in all copies and that both that copyright notice and this
|
|
||||||
// permission notice appear in supporting documentation.
|
|
||||||
// The author or Addison-Wesley Longman make no representations about the
|
|
||||||
// suitability of this software for any purpose. It is provided "as is"
|
|
||||||
// without express or implied warranty.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
// Last update: June 20, 2001
|
|
||||||
|
|
||||||
#include "Singleton.h"
|
|
||||||
|
|
||||||
using namespace Loki::Private;
|
|
||||||
|
|
||||||
Loki::Private::TrackerArray Loki::Private::pTrackerArray = 0;
|
|
||||||
unsigned int Loki::Private::elements = 0;
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// function AtExitFn
|
|
||||||
// Ensures proper destruction of objects with longevity
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
void Loki::Private::AtExitFn()
|
|
||||||
{
|
|
||||||
assert(elements > 0 && pTrackerArray != 0);
|
|
||||||
// Pick the element at the top of the stack
|
|
||||||
LifetimeTracker* pTop = pTrackerArray[elements - 1];
|
|
||||||
// Remove that object off the stack
|
|
||||||
// Don't check errors - realloc with less memory
|
|
||||||
// can't fail
|
|
||||||
pTrackerArray = static_cast<TrackerArray>(realloc(
|
|
||||||
pTrackerArray, sizeof(*pTrackerArray) * --elements));
|
|
||||||
// Destroy the element
|
|
||||||
delete pTop;
|
|
||||||
}
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Change log:
|
|
||||||
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
||||||
// January 10, 2002: Fixed bug in call to realloc - credit due to Nigel Gent and
|
|
||||||
// Eike Petersen
|
|
||||||
// May 08, 2002: Refixed bug in call to realloc
|
|
||||||
// October 12, 2002: Ported to MSVC 6 by Terje Slettebø.
|
|
||||||
// Interface for SingletonHolder changed from using template template
|
|
||||||
// parameters, to using classes with member templates.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
@ -1,499 +0,0 @@
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// The Loki Library
|
|
||||||
// Copyright (c) 2001 by Andrei Alexandrescu
|
|
||||||
// This code accompanies the book:
|
|
||||||
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
|
|
||||||
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
|
|
||||||
// Permission to use, copy, modify, distribute and sell this software for any
|
|
||||||
// purpose is hereby granted without fee, provided that the above copyright
|
|
||||||
// notice appear in all copies and that both that copyright notice and this
|
|
||||||
// permission notice appear in supporting documentation.
|
|
||||||
// The author or Addison-Wesley Longman make no representations about the
|
|
||||||
// suitability of this software for any purpose. It is provided "as is"
|
|
||||||
// without express or implied warranty.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#ifndef SINGLETON_INC_
|
|
||||||
#define SINGLETON_INC_
|
|
||||||
|
|
||||||
#include "Threads.h"
|
|
||||||
#include <algorithm>
|
|
||||||
#include <stdexcept>
|
|
||||||
#include <cassert>
|
|
||||||
#include <cstdlib>
|
|
||||||
#include <new>
|
|
||||||
|
|
||||||
namespace Loki
|
|
||||||
{
|
|
||||||
namespace Private
|
|
||||||
{
|
|
||||||
template< typename T >
|
|
||||||
struct MSVCNeverTrue
|
|
||||||
{
|
|
||||||
enum { value = false };
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class MetaFunctionWrapper, class T>
|
|
||||||
struct Apply
|
|
||||||
{
|
|
||||||
#ifdef _MSC_VER
|
|
||||||
// based on the (non-conforming) MSVC trick from MPL
|
|
||||||
|
|
||||||
template<bool>
|
|
||||||
struct MetaFunctionWrapper_VC : MetaFunctionWrapper {};
|
|
||||||
|
|
||||||
//illegal C++ which causes VC to admit that MetaFunctionWrapper_VC
|
|
||||||
//can have a nested template:
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct MetaFunctionWrapper_VC<true>
|
|
||||||
{template<class> struct VolatileType; };
|
|
||||||
|
|
||||||
typedef typename MetaFunctionWrapper_VC<
|
|
||||||
MSVCNeverTrue<MetaFunctionWrapper>::value
|
|
||||||
>::template VolatileType<T>::Result Result;
|
|
||||||
#else
|
|
||||||
typedef typename MetaFunctionWrapper::template VolatileType<T>::Result Result;
|
|
||||||
#endif
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class LifetimeTracker
|
|
||||||
// Helper class for SetLongevity
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
class LifetimeTracker
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
LifetimeTracker(unsigned int x) : longevity_(x)
|
|
||||||
{}
|
|
||||||
|
|
||||||
virtual ~LifetimeTracker() = 0;
|
|
||||||
|
|
||||||
static bool Compare(const LifetimeTracker* lhs,
|
|
||||||
const LifetimeTracker* rhs)
|
|
||||||
{
|
|
||||||
return lhs->longevity_ > rhs->longevity_;
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
unsigned int longevity_;
|
|
||||||
};
|
|
||||||
|
|
||||||
// Definition required
|
|
||||||
inline LifetimeTracker::~LifetimeTracker() {}
|
|
||||||
|
|
||||||
// Helper data
|
|
||||||
typedef LifetimeTracker** TrackerArray;
|
|
||||||
extern TrackerArray pTrackerArray;
|
|
||||||
extern unsigned int elements;
|
|
||||||
|
|
||||||
// Helper destroyer function
|
|
||||||
template <typename T>
|
|
||||||
struct Deleter
|
|
||||||
{
|
|
||||||
static void Delete(T* pObj)
|
|
||||||
{ delete pObj; }
|
|
||||||
};
|
|
||||||
|
|
||||||
// Concrete lifetime tracker for objects of type T
|
|
||||||
template <typename T, typename Destroyer>
|
|
||||||
class ConcreteLifetimeTracker : public LifetimeTracker
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
ConcreteLifetimeTracker(T* p,unsigned int longevity, Destroyer d)
|
|
||||||
: LifetimeTracker(longevity)
|
|
||||||
, pTracked_(p)
|
|
||||||
, destroyer_(d)
|
|
||||||
{}
|
|
||||||
|
|
||||||
~ConcreteLifetimeTracker()
|
|
||||||
{ destroyer_(pTracked_); }
|
|
||||||
|
|
||||||
private:
|
|
||||||
T* pTracked_;
|
|
||||||
Destroyer destroyer_;
|
|
||||||
};
|
|
||||||
|
|
||||||
void AtExitFn(); // declaration needed below
|
|
||||||
|
|
||||||
} // namespace Private
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// function template SetLongevity
|
|
||||||
// Assigns an object a longevity; ensures ordered destructions of objects
|
|
||||||
// registered thusly during the exit sequence of the application
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template <typename T, typename Destroyer>
|
|
||||||
void SetLongevity(T* pDynObject, unsigned int longevity,
|
|
||||||
Destroyer d = Private::Deleter<T>::Delete)
|
|
||||||
{
|
|
||||||
using namespace Private;
|
|
||||||
|
|
||||||
TrackerArray pNewArray = static_cast<TrackerArray>(
|
|
||||||
realloc(pTrackerArray,
|
|
||||||
sizeof(*pTrackerArray) * (elements + 1)));
|
|
||||||
if (!pNewArray) throw std::bad_alloc();
|
|
||||||
|
|
||||||
// Delayed assignment for exception safety
|
|
||||||
pTrackerArray = pNewArray;
|
|
||||||
|
|
||||||
LifetimeTracker* p = new ConcreteLifetimeTracker<T, Destroyer>(
|
|
||||||
pDynObject, longevity, d);
|
|
||||||
|
|
||||||
// Insert a pointer to the object into the queue
|
|
||||||
TrackerArray pos = std::upper_bound(
|
|
||||||
pTrackerArray,
|
|
||||||
pTrackerArray + elements,
|
|
||||||
p,
|
|
||||||
LifetimeTracker::Compare);
|
|
||||||
std::copy_backward(
|
|
||||||
pos,
|
|
||||||
pTrackerArray + elements,
|
|
||||||
pTrackerArray + elements + 1);
|
|
||||||
*pos = p;
|
|
||||||
++elements;
|
|
||||||
|
|
||||||
// Register a call to AtExitFn
|
|
||||||
atexit(Private::AtExitFn);
|
|
||||||
}
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template CreateUsingNew
|
|
||||||
// Implementation of the CreationPolicy used by SingletonHolder
|
|
||||||
// Creates objects using a straight call to the new operator
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
struct CreateUsingNew
|
|
||||||
{
|
|
||||||
template <class T>
|
|
||||||
static T* Create(T*)
|
|
||||||
{ return new T; }
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
static void Destroy(T* p)
|
|
||||||
{ delete p; }
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template CreateUsingNew
|
|
||||||
// Implementation of the CreationPolicy used by SingletonHolder
|
|
||||||
// Creates objects using a call to std::malloc, followed by a call to the
|
|
||||||
// placement new operator
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
struct CreateUsingMalloc
|
|
||||||
{
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
static T* Create(T*)
|
|
||||||
{
|
|
||||||
void* p = malloc(sizeof(T));
|
|
||||||
if (!p) return 0;
|
|
||||||
return new(p) T;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
static void Destroy(T* p)
|
|
||||||
{
|
|
||||||
p->~T();
|
|
||||||
free(p);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template CreateStatic
|
|
||||||
// Implementation of the CreationPolicy used by SingletonHolder
|
|
||||||
// Creates an object in static memory
|
|
||||||
// Implementation is slightly nonportable because it uses the MaxAlign trick
|
|
||||||
// (an union of all types to ensure proper memory alignment). This trick is
|
|
||||||
// nonportable in theory but highly portable in practice.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
struct CreateStatic
|
|
||||||
{
|
|
||||||
template <class T>
|
|
||||||
static T* Create(T*)
|
|
||||||
{
|
|
||||||
union MaxAlign
|
|
||||||
{
|
|
||||||
char t_[sizeof(T)];
|
|
||||||
short int shortInt_;
|
|
||||||
int int_;
|
|
||||||
long int longInt_;
|
|
||||||
float float_;
|
|
||||||
double double_;
|
|
||||||
long double longDouble_;
|
|
||||||
struct Test;
|
|
||||||
int Test::* pMember_;
|
|
||||||
int (Test::*pMemberFn_)(int);
|
|
||||||
};
|
|
||||||
|
|
||||||
static MaxAlign staticMemory_;
|
|
||||||
return new(&staticMemory_) T;
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
static void Destroy(T* p)
|
|
||||||
{
|
|
||||||
p->~T();
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template DefaultLifetime
|
|
||||||
// Implementation of the LifetimePolicy used by SingletonHolder
|
|
||||||
// Schedules an object's destruction as per C++ rules
|
|
||||||
// Forwards to std::atexit
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
struct DefaultLifetime
|
|
||||||
{
|
|
||||||
template <class T>
|
|
||||||
static void ScheduleDestruction(T*, void (*pFun)())
|
|
||||||
{ atexit(pFun); }
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
static void OnDeadReference(T*)
|
|
||||||
{ throw std::exception("Dead Reference Detected"); }
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template PhoenixSingleton
|
|
||||||
// Implementation of the LifetimePolicy used by SingletonHolder
|
|
||||||
// Schedules an object's destruction as per C++ rules, and it allows object
|
|
||||||
// recreation by not throwing an exception from OnDeadReference
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
class PhoenixSingleton
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
template <class T>
|
|
||||||
static void ScheduleDestruction(T*, void (*pFun)())
|
|
||||||
{
|
|
||||||
#ifndef ATEXIT_FIXED
|
|
||||||
if (!destroyedOnce_)
|
|
||||||
#endif
|
|
||||||
atexit(pFun);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
static void OnDeadReference(T*)
|
|
||||||
{
|
|
||||||
#ifndef ATEXIT_FIXED
|
|
||||||
destroyedOnce_ = true;
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
private:
|
|
||||||
#ifndef ATEXIT_FIXED
|
|
||||||
static bool destroyedOnce_;
|
|
||||||
#endif
|
|
||||||
};
|
|
||||||
|
|
||||||
#ifndef ATEXIT_FIXED
|
|
||||||
bool PhoenixSingleton::destroyedOnce_ = false;
|
|
||||||
#endif
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Adapter
|
|
||||||
// Helper for SingletonWithLongevity below
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
namespace Private
|
|
||||||
{
|
|
||||||
template <class T>
|
|
||||||
struct Adapter
|
|
||||||
{
|
|
||||||
void operator()(T*) { pFun_(); }
|
|
||||||
void (*pFun_)();
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template SingletonWithLongevity
|
|
||||||
// Implementation of the LifetimePolicy used by SingletonHolder
|
|
||||||
// Schedules an object's destruction in order of their longevities
|
|
||||||
// Assumes a visible function GetLongevity(T*) that returns the longevity of the
|
|
||||||
// object
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
class SingletonWithLongevity
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
template <class T>
|
|
||||||
static void ScheduleDestruction(T* pObj, void (*pFun)())
|
|
||||||
{
|
|
||||||
Private::Adapter<T> adapter = { pFun };
|
|
||||||
SetLongevity(pObj, GetLongevity(pObj), adapter);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
static void OnDeadReference(T*)
|
|
||||||
{ throw std::exception("Dead Reference Detected"); }
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template NoDestroy
|
|
||||||
// Implementation of the LifetimePolicy used by SingletonHolder
|
|
||||||
// Never destroys the object
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
struct NoDestroy
|
|
||||||
{
|
|
||||||
template <class T>
|
|
||||||
static void ScheduleDestruction(T*, void (*)())
|
|
||||||
{}
|
|
||||||
|
|
||||||
template <class T>
|
|
||||||
static void OnDeadReference(T*)
|
|
||||||
{}
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template SingletonHolder
|
|
||||||
// Provides Singleton amenities for a type T
|
|
||||||
// To protect that type from spurious instantiations, you have to protect it
|
|
||||||
// yourself.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template
|
|
||||||
<
|
|
||||||
typename T,
|
|
||||||
class CreationPolicy = CreateUsingNew,
|
|
||||||
class LifetimePolicy = DefaultLifetime,
|
|
||||||
class ThreadingModel = SingleThreaded
|
|
||||||
>
|
|
||||||
class SingletonHolder
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
static T& Instance();
|
|
||||||
|
|
||||||
private:
|
|
||||||
// Helpers
|
|
||||||
static void MakeInstance();
|
|
||||||
static void DestroySingleton();
|
|
||||||
|
|
||||||
// Protection
|
|
||||||
SingletonHolder();
|
|
||||||
|
|
||||||
// Data
|
|
||||||
typedef typename Private::Apply<ThreadingModel,T*>::Result PtrInstanceType;
|
|
||||||
|
|
||||||
// typedef typename ThreadingModel::VolatileType<T*>::Result PtrInstanceType;
|
|
||||||
static PtrInstanceType pInstance_;
|
|
||||||
static bool destroyed_;
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// SingletonHolder's data
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template
|
|
||||||
<
|
|
||||||
class T,
|
|
||||||
class C,
|
|
||||||
class L,
|
|
||||||
class M
|
|
||||||
>
|
|
||||||
typename SingletonHolder<T, C, L, M>::PtrInstanceType
|
|
||||||
SingletonHolder<T, C, L, M>::pInstance_;
|
|
||||||
|
|
||||||
template
|
|
||||||
<
|
|
||||||
class T,
|
|
||||||
class C,
|
|
||||||
class L,
|
|
||||||
class M
|
|
||||||
>
|
|
||||||
bool SingletonHolder<T, C, L, M>::destroyed_;
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// SingletonHolder::Instance
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template
|
|
||||||
<
|
|
||||||
class T,
|
|
||||||
class CreationPolicy,
|
|
||||||
class LifetimePolicy,
|
|
||||||
class ThreadingModel
|
|
||||||
>
|
|
||||||
inline T& SingletonHolder<T, CreationPolicy,
|
|
||||||
LifetimePolicy, ThreadingModel>::Instance()
|
|
||||||
{
|
|
||||||
if (!pInstance_)
|
|
||||||
{
|
|
||||||
MakeInstance();
|
|
||||||
}
|
|
||||||
return *pInstance_;
|
|
||||||
}
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// SingletonHolder::MakeInstance (helper for Instance)
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template
|
|
||||||
<
|
|
||||||
class T,
|
|
||||||
class CreationPolicy,
|
|
||||||
class LifetimePolicy,
|
|
||||||
class ThreadingModel
|
|
||||||
>
|
|
||||||
void SingletonHolder<T, CreationPolicy,
|
|
||||||
LifetimePolicy, ThreadingModel>::MakeInstance()
|
|
||||||
{
|
|
||||||
typename ThreadingModel::Lock<T> guard;
|
|
||||||
(void)guard;
|
|
||||||
|
|
||||||
if (!pInstance_)
|
|
||||||
{
|
|
||||||
if (destroyed_)
|
|
||||||
{
|
|
||||||
T* dummy;
|
|
||||||
|
|
||||||
LifetimePolicy::OnDeadReference(dummy);
|
|
||||||
destroyed_ = false;
|
|
||||||
}
|
|
||||||
|
|
||||||
T* dummy;
|
|
||||||
|
|
||||||
pInstance_ = CreationPolicy::Create(dummy);
|
|
||||||
LifetimePolicy::ScheduleDestruction(pInstance_,
|
|
||||||
&DestroySingleton);
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
template
|
|
||||||
<
|
|
||||||
class T,
|
|
||||||
class CreationPolicy,
|
|
||||||
class L,
|
|
||||||
class M
|
|
||||||
>
|
|
||||||
void SingletonHolder<T, CreationPolicy, L, M>::DestroySingleton()
|
|
||||||
{
|
|
||||||
assert(!destroyed_);
|
|
||||||
CreationPolicy::Destroy(pInstance_);
|
|
||||||
pInstance_ = 0;
|
|
||||||
destroyed_ = true;
|
|
||||||
}
|
|
||||||
} // namespace Loki
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Change log:
|
|
||||||
// May 21, 2001: Correct the volatile qualifier - credit due to Darin Adler
|
|
||||||
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
||||||
// January 08, 2002: Fixed bug in call to realloc - credit due to Nigel Gent and
|
|
||||||
// Eike Petersen
|
|
||||||
// March 08, 2002: moved the assignment to pTrackerArray in SetLongevity to fix
|
|
||||||
// exception safety issue. Credit due to Kari Hoijarvi
|
|
||||||
// May 09, 2002: Fixed bug in Compare that caused longevities to act backwards.
|
|
||||||
// Credit due to Scott McDonald.
|
|
||||||
// October 12, 2002: Ported to MSVC 6 by Terje Slettebø.
|
|
||||||
// Interface for SingletonHolder changed from using template template
|
|
||||||
// parameters, to using classes with member templates.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#endif // SINGLETON_INC_
|
|
||||||
|
|
@ -1,213 +0,0 @@
|
||||||
#ifndef THREADS_H_
|
|
||||||
#define THREADS_H_
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// macro DEFAULT_THREADING
|
|
||||||
// Selects the default threading model for certain components of Loki
|
|
||||||
// If you don't define it, it defaults to single-threaded
|
|
||||||
// All classes in Loki have configurable threading model; DEFAULT_THREADING
|
|
||||||
// affects only default template arguments
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
// Last update: June 20, 2001
|
|
||||||
|
|
||||||
#ifndef DEFAULT_THREADING
|
|
||||||
#define DEFAULT_THREADING /**/ ::Loki::SingleThreaded
|
|
||||||
#endif
|
|
||||||
|
|
||||||
namespace Loki
|
|
||||||
{
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template SingleThreaded
|
|
||||||
// Implementation of the ThreadingModel policy used by various classes
|
|
||||||
// Implements a single-threaded model; no synchronization
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
class SingleThreaded
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
template <class Host>
|
|
||||||
struct Lock
|
|
||||||
{
|
|
||||||
Lock() {}
|
|
||||||
Lock(const Host&) {}
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class Host>
|
|
||||||
struct VolatileType
|
|
||||||
{
|
|
||||||
typedef Host Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef int IntType;
|
|
||||||
|
|
||||||
static IntType AtomicAdd(volatile IntType& lval, IntType val)
|
|
||||||
{ return lval += val; }
|
|
||||||
|
|
||||||
static IntType AtomicSubtract(volatile IntType& lval, IntType val)
|
|
||||||
{ return lval -= val; }
|
|
||||||
|
|
||||||
static IntType AtomicMultiply(volatile IntType& lval, IntType val)
|
|
||||||
{ return lval *= val; }
|
|
||||||
|
|
||||||
static IntType AtomicDivide(volatile IntType& lval, IntType val)
|
|
||||||
{ return lval /= val; }
|
|
||||||
|
|
||||||
static IntType AtomicIncrement(volatile IntType& lval)
|
|
||||||
{ return ++lval; }
|
|
||||||
|
|
||||||
static IntType AtomicDecrement(volatile IntType& lval)
|
|
||||||
{ return --lval; }
|
|
||||||
|
|
||||||
static void AtomicAssign(volatile IntType & lval, IntType val)
|
|
||||||
{ lval = val; }
|
|
||||||
|
|
||||||
static void AtomicAssign(IntType & lval, volatile IntType & val)
|
|
||||||
{ lval = val; }
|
|
||||||
};
|
|
||||||
|
|
||||||
#if defined(_MSC_VER) && !defined(__INTEL_COMPILER) && !defined(__MWERKS__)
|
|
||||||
|
|
||||||
#include <windows.h>
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template ObjectLevelLockable
|
|
||||||
// Implementation of the ThreadingModel policy used by various classes
|
|
||||||
// Implements a object-level locking scheme
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
class ObjectLevelLockable
|
|
||||||
{
|
|
||||||
CRITICAL_SECTION mtx_;
|
|
||||||
|
|
||||||
public:
|
|
||||||
ObjectLevelLockable()
|
|
||||||
{
|
|
||||||
InitializeCriticalSection(&mtx_);
|
|
||||||
}
|
|
||||||
|
|
||||||
~ObjectLevelLockable()
|
|
||||||
{
|
|
||||||
DeleteCriticalSection(&mtx_);
|
|
||||||
}
|
|
||||||
|
|
||||||
template <class Host>
|
|
||||||
class Lock
|
|
||||||
{
|
|
||||||
ObjectLevelLockable& host_;
|
|
||||||
|
|
||||||
Lock(const Lock&);
|
|
||||||
Lock& operator=(const Lock&);
|
|
||||||
public:
|
|
||||||
Lock(Host& host) : host_(host)
|
|
||||||
{
|
|
||||||
::EnterCriticalSection(&host_.mtx_);
|
|
||||||
}
|
|
||||||
~Lock()
|
|
||||||
{
|
|
||||||
::LeaveCriticalSection(&host_.mtx_);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class Host>
|
|
||||||
struct VolatileType
|
|
||||||
{
|
|
||||||
typedef volatile Host Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef LONG IntType;
|
|
||||||
|
|
||||||
static IntType AtomicIncrement(volatile IntType& lval)
|
|
||||||
{ return InterlockedIncrement(&const_cast<IntType&>(lval)); }
|
|
||||||
|
|
||||||
static IntType AtomicDecrement(volatile IntType& lval)
|
|
||||||
{ return InterlockedDecrement(&const_cast<IntType&>(lval)); }
|
|
||||||
|
|
||||||
static void AtomicAssign(volatile IntType& lval, IntType val)
|
|
||||||
{ InterlockedExchange(&const_cast<IntType&>(lval), val); }
|
|
||||||
|
|
||||||
static void AtomicAssign(IntType& lval, volatile IntType& val)
|
|
||||||
{ InterlockedExchange(&lval, val); }
|
|
||||||
};
|
|
||||||
|
|
||||||
class ClassLevelLockable
|
|
||||||
{
|
|
||||||
struct Initializer;
|
|
||||||
friend struct Initializer;
|
|
||||||
struct Initializer
|
|
||||||
{
|
|
||||||
Initializer()
|
|
||||||
{
|
|
||||||
InitializeCriticalSection(&mtx_);
|
|
||||||
}
|
|
||||||
~Initializer()
|
|
||||||
{
|
|
||||||
DeleteCriticalSection(&mtx_);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
static Initializer initializer_;
|
|
||||||
|
|
||||||
public:
|
|
||||||
static CRITICAL_SECTION mtx_;
|
|
||||||
|
|
||||||
template <class Host>
|
|
||||||
class Lock
|
|
||||||
{
|
|
||||||
Lock(const Lock&);
|
|
||||||
Lock& operator=(const Lock&);
|
|
||||||
public:
|
|
||||||
Lock()
|
|
||||||
{
|
|
||||||
EnterCriticalSection(&mtx_);
|
|
||||||
}
|
|
||||||
Lock(Host&)
|
|
||||||
{
|
|
||||||
EnterCriticalSection(&mtx_);
|
|
||||||
}
|
|
||||||
~Lock()
|
|
||||||
{
|
|
||||||
LeaveCriticalSection(&mtx_);
|
|
||||||
}
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class Host>
|
|
||||||
struct VolatileType
|
|
||||||
{
|
|
||||||
typedef Host Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef LONG IntType;
|
|
||||||
|
|
||||||
static IntType AtomicIncrement(volatile IntType& lval)
|
|
||||||
{ return InterlockedIncrement(&const_cast<IntType&>(lval)); }
|
|
||||||
|
|
||||||
static IntType AtomicDecrement(volatile IntType& lval)
|
|
||||||
{ return InterlockedDecrement(&const_cast<IntType&>(lval)); }
|
|
||||||
|
|
||||||
static void AtomicAssign(volatile IntType& lval, IntType val)
|
|
||||||
{ InterlockedExchange(&const_cast<IntType&>(lval), val); }
|
|
||||||
|
|
||||||
static void AtomicAssign(IntType& lval, volatile IntType& val)
|
|
||||||
{ InterlockedExchange(&lval, val); }
|
|
||||||
};
|
|
||||||
|
|
||||||
CRITICAL_SECTION ClassLevelLockable::mtx_;
|
|
||||||
|
|
||||||
ClassLevelLockable::Initializer ClassLevelLockable::initializer_;
|
|
||||||
|
|
||||||
#endif
|
|
||||||
}
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Change log:
|
|
||||||
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
||||||
// January 10, 2002: Fixed bug in AtomicDivide - credit due to Jordi Guerrero
|
|
||||||
// August 14, 2002: Changed some AtomicDivide's to AtomicDecrement's MKH
|
|
||||||
// October 12, 2002: Ported to MSVC 6 by Terje Slettebø.
|
|
||||||
// SingleThreaded, ObjectLevelLockable and ClassLevelLockable changed from
|
|
||||||
// templates to classes with member templates, to be usable as policies in
|
|
||||||
// the other ported components.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#endif
|
|
||||||
|
|
@ -1,106 +0,0 @@
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// The Loki Library
|
|
||||||
// Copyright (c) 2001 by Andrei Alexandrescu
|
|
||||||
// This code accompanies the book:
|
|
||||||
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
|
|
||||||
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
|
|
||||||
// Permission to use, copy, modify, distribute and sell this software for any
|
|
||||||
// purpose is hereby granted without fee, provided that the above copyright
|
|
||||||
// notice appear in all copies and that both that copyright notice and this
|
|
||||||
// permission notice appear in supporting documentation.
|
|
||||||
// The author or Addison-Wesley Longman make no representations about the
|
|
||||||
// suitability of this software for any purpose. It is provided "as is"
|
|
||||||
// without express or implied warranty.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
// Last update: June 20, 2001
|
|
||||||
|
|
||||||
#ifndef TYPEINFO_INC_
|
|
||||||
#define TYPEINFO_INC_
|
|
||||||
|
|
||||||
#include <typeinfo>
|
|
||||||
#include <cassert>
|
|
||||||
#include "Typelist.h"
|
|
||||||
|
|
||||||
namespace Loki
|
|
||||||
{
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class TypeInfo
|
|
||||||
// Purpose: offer a first-class, comparable wrapper over std::type_info
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
class TypeInfo
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
// Constructors
|
|
||||||
TypeInfo(); // needed for containers
|
|
||||||
TypeInfo(const std::type_info&); // non-explicit
|
|
||||||
|
|
||||||
// Access for the wrapped std::type_info
|
|
||||||
const std::type_info& Get() const;
|
|
||||||
// Compatibility functions
|
|
||||||
bool before(const TypeInfo& rhs) const;
|
|
||||||
const char* name() const;
|
|
||||||
|
|
||||||
private:
|
|
||||||
const std::type_info* pInfo_;
|
|
||||||
};
|
|
||||||
|
|
||||||
// Implementation
|
|
||||||
|
|
||||||
inline TypeInfo::TypeInfo()
|
|
||||||
{
|
|
||||||
class Nil {};
|
|
||||||
pInfo_ = &typeid(Nil);
|
|
||||||
assert(pInfo_);
|
|
||||||
}
|
|
||||||
|
|
||||||
inline TypeInfo::TypeInfo(const std::type_info& ti)
|
|
||||||
: pInfo_(&ti)
|
|
||||||
{ assert(pInfo_); }
|
|
||||||
|
|
||||||
inline bool TypeInfo::before(const TypeInfo& rhs) const
|
|
||||||
{
|
|
||||||
assert(pInfo_);
|
|
||||||
return pInfo_->before(*rhs.pInfo_);
|
|
||||||
}
|
|
||||||
|
|
||||||
inline const std::type_info& TypeInfo::Get() const
|
|
||||||
{
|
|
||||||
assert(pInfo_);
|
|
||||||
return *pInfo_;
|
|
||||||
}
|
|
||||||
|
|
||||||
inline const char* TypeInfo::name() const
|
|
||||||
{
|
|
||||||
assert(pInfo_);
|
|
||||||
return pInfo_->name();
|
|
||||||
}
|
|
||||||
|
|
||||||
// Comparison operators
|
|
||||||
|
|
||||||
inline bool operator==(const TypeInfo& lhs, const TypeInfo& rhs)
|
|
||||||
{ return lhs.Get() == rhs.Get(); }
|
|
||||||
|
|
||||||
inline bool operator<(const TypeInfo& lhs, const TypeInfo& rhs)
|
|
||||||
{ return lhs.before(rhs); }
|
|
||||||
|
|
||||||
inline bool operator!=(const TypeInfo& lhs, const TypeInfo& rhs)
|
|
||||||
{ return !(lhs == rhs); }
|
|
||||||
|
|
||||||
inline bool operator>(const TypeInfo& lhs, const TypeInfo& rhs)
|
|
||||||
{ return rhs < lhs; }
|
|
||||||
|
|
||||||
inline bool operator<=(const TypeInfo& lhs, const TypeInfo& rhs)
|
|
||||||
{ return !(lhs > rhs); }
|
|
||||||
|
|
||||||
inline bool operator>=(const TypeInfo& lhs, const TypeInfo& rhs)
|
|
||||||
{ return !(lhs < rhs); }
|
|
||||||
}
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Change log:
|
|
||||||
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#endif // TYPEINFO_INC_
|
|
||||||
|
|
@ -1,302 +0,0 @@
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// The Loki Library
|
|
||||||
// Copyright (c) 2001 by Andrei Alexandrescu
|
|
||||||
// This code accompanies the book:
|
|
||||||
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
|
|
||||||
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
|
|
||||||
// Permission to use, copy, modify, distribute and sell this software for any
|
|
||||||
// purpose is hereby granted without fee, provided that the above copyright
|
|
||||||
// notice appear in all copies and that both that copyright notice and this
|
|
||||||
// permission notice appear in supporting documentation.
|
|
||||||
// The author or Addison-Welsey Longman make no representations about the
|
|
||||||
// suitability of this software for any purpose. It is provided "as is"
|
|
||||||
// without express or implied warranty.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
// Last update: August 22, 2001
|
|
||||||
|
|
||||||
#ifndef TYPEMANIP_INC_
|
|
||||||
#define TYPEMANIP_INC_
|
|
||||||
|
|
||||||
namespace Loki {
|
|
||||||
|
|
||||||
namespace Private {
|
|
||||||
|
|
||||||
struct big { char c[2]; };
|
|
||||||
|
|
||||||
struct any {
|
|
||||||
template<typename T>
|
|
||||||
any(const T&);
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace Private
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Int2Type
|
|
||||||
// Converts each integral constant into a unique type
|
|
||||||
// Invocation: Int2Type<v> where v is a compile-time constant integral
|
|
||||||
// Defines 'value', an enum that evaluates to v
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template <int v>
|
|
||||||
struct Int2Type
|
|
||||||
{
|
|
||||||
enum { value = v };
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Type2Type
|
|
||||||
// Converts each type into a unique, insipid type
|
|
||||||
// Invocation Type2Type<T> where T is a type
|
|
||||||
// Defines the type OriginalType which maps back to T
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
struct Type2Type
|
|
||||||
{
|
|
||||||
typedef T OriginalType;
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Select
|
|
||||||
// Selects one of two types based upon a boolean constant
|
|
||||||
// Invocation: Select<flag, T, U>::Result
|
|
||||||
// where:
|
|
||||||
// flag is a compile-time boolean constant
|
|
||||||
// T and U are types
|
|
||||||
// Result evaluates to T if flag is true, and to U otherwise.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
namespace Private {
|
|
||||||
|
|
||||||
namespace Select_ {
|
|
||||||
|
|
||||||
struct ChooseT {
|
|
||||||
template<typename T, typename U>
|
|
||||||
struct Choose {
|
|
||||||
typedef T Result;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
struct ChooseU {
|
|
||||||
template<typename T, typename U>
|
|
||||||
struct Choose {
|
|
||||||
typedef U Result;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template<bool flag>
|
|
||||||
struct Selector {
|
|
||||||
typedef ChooseT Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct Selector<false> {
|
|
||||||
typedef ChooseU Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace Select_
|
|
||||||
|
|
||||||
} // namespace Private
|
|
||||||
|
|
||||||
template<bool flag, typename T, typename U>
|
|
||||||
struct Select {
|
|
||||||
private:
|
|
||||||
typedef typename Private::Select_::Selector<flag>::Result selector;
|
|
||||||
public:
|
|
||||||
typedef typename selector::Choose<T, U>::Result Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
namespace Private {
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
struct is_void {
|
|
||||||
enum { value = 0 };
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct is_void<void> {
|
|
||||||
enum { value = 1 };
|
|
||||||
};
|
|
||||||
|
|
||||||
namespace is_same_ {
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
char test_same(T*, T*);
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
big test_same(T*, any);
|
|
||||||
|
|
||||||
template<typename T, typename U>
|
|
||||||
struct is_same_imp {
|
|
||||||
static T t;
|
|
||||||
static U u;
|
|
||||||
enum { result = sizeof(test_same(&t, &u)) == sizeof(char) };
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace is_same_
|
|
||||||
|
|
||||||
template<typename T, typename U>
|
|
||||||
struct is_same {
|
|
||||||
enum { voidT = is_void<T>::value };
|
|
||||||
enum { voidU = is_void<U>::value };
|
|
||||||
struct BothVoid {
|
|
||||||
enum { result = 1 };
|
|
||||||
};
|
|
||||||
struct OneVoid {
|
|
||||||
enum { result = 0 };
|
|
||||||
};
|
|
||||||
typedef typename Select<voidT & voidU,
|
|
||||||
BothVoid,
|
|
||||||
typename Select<voidT | voidU,
|
|
||||||
OneVoid,
|
|
||||||
is_same_::is_same_imp<T, U>
|
|
||||||
>::Result
|
|
||||||
>::Result tester;
|
|
||||||
enum { result = tester::result };
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace Private
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Conversion
|
|
||||||
// Figures out the conversion relationships between two types
|
|
||||||
// Invocations (T and U are types):
|
|
||||||
// a) Conversion<T, U>::exists
|
|
||||||
// returns (at compile time) true if there is an implicit conversion from T
|
|
||||||
// to U (example: Derived to Base)
|
|
||||||
// b) Conversion<T, U>::exists2Way
|
|
||||||
// returns (at compile time) true if there are both conversions from T
|
|
||||||
// to U and from U to T (example: int to char and back)
|
|
||||||
// c) Conversion<T, U>::sameType
|
|
||||||
// returns (at compile time) true if T and U represent the same type
|
|
||||||
//
|
|
||||||
// Caveat: might not work if T and U are in a private inheritance hierarchy.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
namespace Private {
|
|
||||||
|
|
||||||
namespace Conversion_ {
|
|
||||||
|
|
||||||
#ifdef _MSC_VER
|
|
||||||
#pragma warning(push)
|
|
||||||
#pragma warning(disable:4181)
|
|
||||||
#pragma warning(disable:4800)
|
|
||||||
#pragma warning(disable:4244)
|
|
||||||
#endif
|
|
||||||
template<typename T, typename U>
|
|
||||||
struct Determine {
|
|
||||||
template<typename X, typename Y>
|
|
||||||
struct tester {
|
|
||||||
static char test(X, Y);
|
|
||||||
static big test(any, any);
|
|
||||||
};
|
|
||||||
static T t;
|
|
||||||
static U u;
|
|
||||||
enum { exists = sizeof(tester<T, U>::test(t, t)) == sizeof(char) };
|
|
||||||
enum { exists2Way = exists & (sizeof(tester<U, T>::test(u, u)) == sizeof(char)) };
|
|
||||||
enum { sameType = exists2Way & is_same<T, U>::result };
|
|
||||||
};
|
|
||||||
#ifdef _MSC_VER
|
|
||||||
#pragma warning(pop)
|
|
||||||
#endif
|
|
||||||
|
|
||||||
} // namespace Conversion_
|
|
||||||
|
|
||||||
} // namespace Private
|
|
||||||
|
|
||||||
template<typename T, typename U>
|
|
||||||
struct Conversion {
|
|
||||||
private:
|
|
||||||
enum { voidT = Private::is_void<T>::value };
|
|
||||||
enum { voidU = Private::is_void<U>::value };
|
|
||||||
|
|
||||||
struct both_void {
|
|
||||||
enum { exists = 1, exists2Way = 1, sameType = 1 };
|
|
||||||
};
|
|
||||||
|
|
||||||
struct one_void {
|
|
||||||
enum { exists = 1, exists2Way = 0, sameType = 0 };
|
|
||||||
};
|
|
||||||
|
|
||||||
typedef typename Select<voidT & voidU,
|
|
||||||
both_void,
|
|
||||||
typename Select<voidT | voidU,
|
|
||||||
one_void,
|
|
||||||
Private::Conversion_::Determine<T, U>
|
|
||||||
>::Result
|
|
||||||
>::Result Chooser;
|
|
||||||
public:
|
|
||||||
enum { exists = Chooser::exists };
|
|
||||||
enum { exists2Way = Chooser::exists2Way };
|
|
||||||
enum { sameType = Chooser::sameType };
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template SuperSubclass
|
|
||||||
// Invocation: SuperSubclass<B, D>::value where B and D are types.
|
|
||||||
// Returns true if B is a public base of D, or if B and D are aliases of the
|
|
||||||
// same type.
|
|
||||||
//
|
|
||||||
// Caveat: might not work if T and U are in a private inheritance hierarchy.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template <class T, class U>
|
|
||||||
struct SuperSubclass
|
|
||||||
{
|
|
||||||
enum { value = (::Loki::Conversion<const volatile U*, const volatile T*>::exists &&
|
|
||||||
!::Loki::Conversion<const volatile T*, const volatile void*>::sameType) };
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template SuperSubclassStrict
|
|
||||||
// Invocation: SuperSubclassStrict<B, D>::value where B and D are types.
|
|
||||||
// Returns true if B is a public base of D.
|
|
||||||
//
|
|
||||||
// Caveat: might not work if T and U are in a private inheritance hierarchy.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template<class T,class U>
|
|
||||||
struct SuperSubclassStrict
|
|
||||||
{
|
|
||||||
enum { value = (::Loki::Conversion<const volatile U*, const volatile T*>::exists &&
|
|
||||||
!::Loki::Conversion<const volatile T*, const volatile void*>::sameType &&
|
|
||||||
!::Loki::Conversion<const volatile T*, const volatile U*>::sameType) };
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace Loki
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// macro SUPERSUBCLASS
|
|
||||||
// Invocation: SUPERSUBCLASS(B, D) where B and D are types.
|
|
||||||
// Returns true if B is a public base of D, or if B and D are aliases of the
|
|
||||||
// same type.
|
|
||||||
//
|
|
||||||
// Caveat: might not work if T and U are in a private inheritance hierarchy.
|
|
||||||
// Deprecated: Use SuperSubclass class template instead.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#define SUPERSUBCLASS(T, U) \
|
|
||||||
::Loki::SuperSubclass<T,U>::value
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// macro SUPERSUBCLASS_STRICT
|
|
||||||
// Invocation: SUPERSUBCLASS(B, D) where B and D are types.
|
|
||||||
// Returns true if B is a public base of D.
|
|
||||||
//
|
|
||||||
// Caveat: might not work if T and U are in a private inheritance hierarchy.
|
|
||||||
// Deprecated: Use SuperSubclassStrict class template instead.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#define SUPERSUBCLASS_STRICT(T, U) \
|
|
||||||
::Loki::SuperSubclassStrict<T,U>::value
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Change log:
|
|
||||||
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
||||||
// August 22, 2001: ported by Jonathan H Lundquist to MSVC
|
|
||||||
// October 12, 2002: Added SuperSubclass and SuperSubclassStrict templates.
|
|
||||||
// The corresponding macros are deprecated. T.S.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#endif // TYPEMANIP_INC_
|
|
||||||
|
|
@ -1,374 +0,0 @@
|
||||||
#ifndef TYPETRAITS_INC_
|
|
||||||
#define TYPETRAITS_INC_
|
|
||||||
|
|
||||||
#include "Typelist.h"
|
|
||||||
|
|
||||||
namespace Loki
|
|
||||||
{
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template IsCustomUnsignedInt
|
|
||||||
// Offers a means to integrate nonstandard built-in unsigned integral types
|
|
||||||
// (such as unsigned __int64 or unsigned long long int) with the TypeTraits
|
|
||||||
// class template defined below.
|
|
||||||
// Invocation: IsCustomUnsignedInt<T> where T is any type
|
|
||||||
// Defines 'value', an enum that is 1 iff T is a custom built-in unsigned
|
|
||||||
// integral type
|
|
||||||
// Specialize this class template for nonstandard unsigned integral types
|
|
||||||
// and define value = 1 in those specializations
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
struct IsCustomUnsignedInt
|
|
||||||
{
|
|
||||||
enum { value = 0 };
|
|
||||||
};
|
|
||||||
|
|
||||||
#ifdef _MSC_VER
|
|
||||||
template<>
|
|
||||||
struct IsCustomUnsignedInt<unsigned __int64> {
|
|
||||||
enum { value = 1 };
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template IsCustomSignedInt
|
|
||||||
// Offers a means to integrate nonstandard built-in unsigned integral types
|
|
||||||
// (such as unsigned __int64 or unsigned long long int) with the TypeTraits
|
|
||||||
// class template defined below.
|
|
||||||
// Invocation: IsCustomSignedInt<T> where T is any type
|
|
||||||
// Defines 'value', an enum that is 1 iff T is a custom built-in signed
|
|
||||||
// integral type
|
|
||||||
// Specialize this class template for nonstandard unsigned integral types
|
|
||||||
// and define value = 1 in those specializations
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
struct IsCustomSignedInt
|
|
||||||
{
|
|
||||||
enum { value = 0 };
|
|
||||||
};
|
|
||||||
|
|
||||||
#ifdef _MSC_VER
|
|
||||||
template<>
|
|
||||||
struct IsCustomSignedInt<__int64> {
|
|
||||||
enum { value = 1 };
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template IsCustomFloat
|
|
||||||
// Offers a means to integrate nonstandard floating point types with the
|
|
||||||
// TypeTraits class template defined below.
|
|
||||||
// Invocation: IsCustomFloat<T> where T is any type
|
|
||||||
// Defines 'value', an enum that is 1 iff T is a custom built-in
|
|
||||||
// floating point type
|
|
||||||
// Specialize this class template for nonstandard unsigned integral types
|
|
||||||
// and define value = 1 in those specializations
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
struct IsCustomFloat
|
|
||||||
{
|
|
||||||
enum { value = 0 };
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Helper types for class template TypeTraits defined below
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
namespace Private
|
|
||||||
{
|
|
||||||
typedef TYPELIST_4(unsigned char, unsigned short int,
|
|
||||||
unsigned int, unsigned long int) StdUnsignedInts;
|
|
||||||
typedef TYPELIST_4(signed char, short int,
|
|
||||||
int, long int) StdSignedInts;
|
|
||||||
typedef TYPELIST_3(bool, char, wchar_t) StdOtherInts;
|
|
||||||
typedef TYPELIST_3(float, double, long double) StdFloats;
|
|
||||||
|
|
||||||
char test_ptr(const volatile void*, const volatile void*);
|
|
||||||
big test_ptr(any, any);
|
|
||||||
|
|
||||||
template<typename T>
|
|
||||||
T* unrefptr(T&);
|
|
||||||
|
|
||||||
char test_const(const volatile void*);
|
|
||||||
big test_const(volatile void*);
|
|
||||||
char test_volatile(const volatile void*);
|
|
||||||
big test_volatile(const void*);
|
|
||||||
|
|
||||||
template<typename V, typename X>
|
|
||||||
char test_mptr(V X::*, any);
|
|
||||||
|
|
||||||
big test_mptr(any, any);
|
|
||||||
|
|
||||||
template<bool isReference>
|
|
||||||
struct AddReferenceImp {
|
|
||||||
template<typename T>
|
|
||||||
struct Imp {
|
|
||||||
typedef T Result;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct AddReferenceImp<false> {
|
|
||||||
template<typename T>
|
|
||||||
struct Imp {
|
|
||||||
typedef T& Result;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
#ifndef _MSC_VER
|
|
||||||
template <class U> struct PointerTraits
|
|
||||||
{
|
|
||||||
enum { result = false };
|
|
||||||
typedef NullType PointeeType;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class U> struct PointerTraits<U*>
|
|
||||||
{
|
|
||||||
enum { result = true };
|
|
||||||
typedef U PointeeType;
|
|
||||||
};
|
|
||||||
#else
|
|
||||||
template<typename U>
|
|
||||||
struct PointerTraits {
|
|
||||||
private:
|
|
||||||
static U u;
|
|
||||||
public:
|
|
||||||
typedef void PointeeType; // unable to determine correctly
|
|
||||||
enum { result = sizeof(Private::test_ptr(&u, u)) == sizeof(char) };
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct PointerTraits<void> {
|
|
||||||
typedef void PointeeType;
|
|
||||||
enum { result = 0 };
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
#ifndef _MSC_VER
|
|
||||||
template <class U> struct ReferenceTraits
|
|
||||||
{
|
|
||||||
enum { result = false };
|
|
||||||
typedef U ReferredType;
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class U> struct ReferenceTraits<U&>
|
|
||||||
{
|
|
||||||
enum { result = true };
|
|
||||||
typedef U ReferredType;
|
|
||||||
};
|
|
||||||
#else
|
|
||||||
#pragma warning(push)
|
|
||||||
#pragma warning(disable:4181)
|
|
||||||
template<typename U>
|
|
||||||
struct ReferenceTraits {
|
|
||||||
typedef U const volatile cv_u;
|
|
||||||
static cv_u u;
|
|
||||||
public:
|
|
||||||
enum { result = (sizeof(Private::test_const(&u)) != sizeof(char))
|
|
||||||
| (sizeof(Private::test_volatile(&u)) != sizeof(char)) };
|
|
||||||
typedef void ReferredType; // unable to determine correctly
|
|
||||||
};
|
|
||||||
#pragma warning(pop)
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct ReferenceTraits<void> {
|
|
||||||
enum { result = 0 };
|
|
||||||
typedef void ReferredType;
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
#ifndef _MSC_VER
|
|
||||||
template <class U> struct PToMTraits
|
|
||||||
{
|
|
||||||
enum { result = false };
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class U, class V>
|
|
||||||
struct PToMTraits<U V::*>
|
|
||||||
{
|
|
||||||
enum { result = true };
|
|
||||||
};
|
|
||||||
#else
|
|
||||||
template<typename U>
|
|
||||||
struct PToMTraits {
|
|
||||||
private:
|
|
||||||
static U u;
|
|
||||||
public:
|
|
||||||
enum { result = sizeof(Private::test_mptr(u, &u)) == sizeof(char) };
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct PToMTraits<void> {
|
|
||||||
enum { result = 0 };
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
#ifndef _MSC_VER
|
|
||||||
template <class U> struct UnConst
|
|
||||||
{
|
|
||||||
typedef U Result;
|
|
||||||
enum { isConst = 0 };
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class U> struct UnConst<const U>
|
|
||||||
{
|
|
||||||
typedef U Result;
|
|
||||||
enum { isConst = 1 };
|
|
||||||
};
|
|
||||||
#else
|
|
||||||
template<typename U>
|
|
||||||
struct UnConst {
|
|
||||||
private:
|
|
||||||
static U u;
|
|
||||||
public:
|
|
||||||
typedef void Result; // unable to determine correctly
|
|
||||||
enum { isConst = sizeof(Private::test_const(Private::unrefptr(u))) == sizeof(char) };
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct UnConst<void> {
|
|
||||||
typedef void Result;
|
|
||||||
enum { isConst = 0 };
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
#ifndef _MSC_VER
|
|
||||||
template <class U> struct UnVolatile
|
|
||||||
{
|
|
||||||
typedef U Result;
|
|
||||||
enum { isVolatile = 0 };
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class U> struct UnVolatile<volatile U>
|
|
||||||
{
|
|
||||||
typedef U Result;
|
|
||||||
enum { isVolatile = 1 };
|
|
||||||
};
|
|
||||||
#else
|
|
||||||
template<typename U>
|
|
||||||
struct UnVolatile {
|
|
||||||
private:
|
|
||||||
static U u;
|
|
||||||
public:
|
|
||||||
typedef void Result; // unable to determine correctly
|
|
||||||
enum { isVolatile = sizeof(Private::test_volatile(Private::unrefptr(u))) == sizeof(char) };
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct UnVolatile<void> {
|
|
||||||
typedef void Result;
|
|
||||||
enum { isVolatile = 0 };
|
|
||||||
};
|
|
||||||
#endif
|
|
||||||
template<typename U, bool isReference>
|
|
||||||
struct AddReference {
|
|
||||||
typedef typename Private::AddReferenceImp<isReference>::template Imp<U>::Result Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct AddReference<void, false> {
|
|
||||||
typedef void Result;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template TypeTraits
|
|
||||||
// Figures out various properties of any given type
|
|
||||||
// Invocations (T is a type):
|
|
||||||
// a) TypeTraits<T>::isPointer
|
|
||||||
// returns (at compile time) true if T is a pointer type
|
|
||||||
// b) TypeTraits<T>::PointeeType
|
|
||||||
// returns the type to which T points is T is a pointer type, NullType otherwise
|
|
||||||
// a) TypeTraits<T>::isReference
|
|
||||||
// returns (at compile time) true if T is a reference type
|
|
||||||
// b) TypeTraits<T>::ReferredType
|
|
||||||
// returns the type to which T refers is T is a reference type, NullType
|
|
||||||
// otherwise
|
|
||||||
// c) TypeTraits<T>::isMemberPointer
|
|
||||||
// returns (at compile time) true if T is a pointer to member type
|
|
||||||
// d) TypeTraits<T>::isStdUnsignedInt
|
|
||||||
// returns (at compile time) true if T is a standard unsigned integral type
|
|
||||||
// e) TypeTraits<T>::isStdSignedInt
|
|
||||||
// returns (at compile time) true if T is a standard signed integral type
|
|
||||||
// f) TypeTraits<T>::isStdIntegral
|
|
||||||
// returns (at compile time) true if T is a standard integral type
|
|
||||||
// g) TypeTraits<T>::isStdFloat
|
|
||||||
// returns (at compile time) true if T is a standard floating-point type
|
|
||||||
// h) TypeTraits<T>::isStdArith
|
|
||||||
// returns (at compile time) true if T is a standard arithmetic type
|
|
||||||
// i) TypeTraits<T>::isStdFundamental
|
|
||||||
// returns (at compile time) true if T is a standard fundamental type
|
|
||||||
// j) TypeTraits<T>::isUnsignedInt
|
|
||||||
// returns (at compile time) true if T is a unsigned integral type
|
|
||||||
// k) TypeTraits<T>::isSignedInt
|
|
||||||
// returns (at compile time) true if T is a signed integral type
|
|
||||||
// l) TypeTraits<T>::isIntegral
|
|
||||||
// returns (at compile time) true if T is a integral type
|
|
||||||
// m) TypeTraits<T>::isFloat
|
|
||||||
// returns (at compile time) true if T is a floating-point type
|
|
||||||
// n) TypeTraits<T>::isArith
|
|
||||||
// returns (at compile time) true if T is a arithmetic type
|
|
||||||
// o) TypeTraits<T>::isFundamental
|
|
||||||
// returns (at compile time) true if T is a fundamental type
|
|
||||||
// p) TypeTraits<T>::ParameterType
|
|
||||||
// returns the optimal type to be used as a parameter for functions that take Ts
|
|
||||||
// q) TypeTraits<T>::isConst
|
|
||||||
// returns (at compile time) true if T is a const-qualified type
|
|
||||||
// r) TypeTraits<T>::NonConstType
|
|
||||||
// removes the 'const' qualifier from T, if any
|
|
||||||
// s) TypeTraits<T>::isVolatile
|
|
||||||
// returns (at compile time) true if T is a volatile-qualified type
|
|
||||||
// t) TypeTraits<T>::NonVolatileType
|
|
||||||
// removes the 'volatile' qualifier from T, if any
|
|
||||||
// u) TypeTraits<T>::UnqualifiedType
|
|
||||||
// removes both the 'const' and 'volatile' qualifiers from T, if any
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template <typename T>
|
|
||||||
class TypeTraits
|
|
||||||
{
|
|
||||||
public:
|
|
||||||
enum { isPointer = Private::PointerTraits<T>::result };
|
|
||||||
typedef typename Private::PointerTraits<T>::PointeeType PointeeType;
|
|
||||||
|
|
||||||
enum { isReference = Private::ReferenceTraits<T>::result };
|
|
||||||
typedef typename Private::ReferenceTraits<T>::ReferredType ReferredType;
|
|
||||||
|
|
||||||
enum { isMemberPointer = Private::PToMTraits<T>::result };
|
|
||||||
|
|
||||||
enum { isStdUnsignedInt =
|
|
||||||
TL::IndexOf<Private::StdUnsignedInts, T>::value >= 0 };
|
|
||||||
enum { isStdSignedInt =
|
|
||||||
TL::IndexOf<Private::StdSignedInts, T>::value >= 0 };
|
|
||||||
enum { isStdIntegral = isStdUnsignedInt || isStdSignedInt ||
|
|
||||||
TL::IndexOf<Private::StdOtherInts, T>::value >= 0 };
|
|
||||||
enum { isStdFloat = TL::IndexOf<Private::StdFloats, T>::value >= 0 };
|
|
||||||
enum { isStdArith = isStdIntegral || isStdFloat };
|
|
||||||
enum { isStdFundamental = isStdArith || isStdFloat ||
|
|
||||||
Conversion<T, void>::sameType };
|
|
||||||
|
|
||||||
enum { isUnsignedInt = isStdUnsignedInt || IsCustomUnsignedInt<T>::value };
|
|
||||||
enum { isSignedInt = isStdSignedInt || IsCustomSignedInt<T>::value };
|
|
||||||
enum { isIntegral = isStdIntegral || isUnsignedInt || isSignedInt };
|
|
||||||
enum { isFloat = isStdFloat || IsCustomFloat<T>::value };
|
|
||||||
enum { isArith = isIntegral || isFloat };
|
|
||||||
enum { isFundamental = isStdFundamental || isArith || isFloat };
|
|
||||||
|
|
||||||
typedef typename Select<isStdArith || isPointer || isMemberPointer, T,
|
|
||||||
typename Private::AddReference<T, isReference>::Result
|
|
||||||
>::Result ParameterType;
|
|
||||||
|
|
||||||
enum { isConst = Private::UnConst<T>::isConst };
|
|
||||||
typedef typename Private::UnConst<T>::Result NonConstType;
|
|
||||||
enum { isVolatile = Private::UnVolatile<T>::isVolatile };
|
|
||||||
typedef typename Private::UnVolatile<T>::Result NonVolatileType;
|
|
||||||
typedef typename Private::UnVolatile<typename Private::UnConst<T>::Result>::Result
|
|
||||||
UnqualifiedType;
|
|
||||||
};
|
|
||||||
}
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Change log:
|
|
||||||
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
||||||
// August 22, 2001: ported by Jonathan H Lundquist to MSVC
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#endif // TYPETRAITS_INC_
|
|
||||||
|
|
@ -1,788 +0,0 @@
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// The Loki Library
|
|
||||||
// Copyright (c) 2001 by Andrei Alexandrescu
|
|
||||||
// This code accompanies the book:
|
|
||||||
// Alexandrescu, Andrei. "Modern C++ Design: Generic Programming and Design
|
|
||||||
// Patterns Applied". Copyright (c) 2001. Addison-Wesley.
|
|
||||||
// Permission to use, copy, modify, distribute and sell this software for any
|
|
||||||
// purpose is hereby granted without fee, provided that the above copyright
|
|
||||||
// notice appear in all copies and that both that copyright notice and this
|
|
||||||
// permission notice appear in supporting documentation.
|
|
||||||
// The author or Addison-Welsey Longman make no representations about the
|
|
||||||
// suitability of this software for any purpose. It is provided "as is"
|
|
||||||
// without express or implied warranty.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
// Last update: August 22, 2001
|
|
||||||
|
|
||||||
#ifndef TYPELIST_INC_
|
|
||||||
#define TYPELIST_INC_
|
|
||||||
|
|
||||||
#include "NullType.h"
|
|
||||||
#include "TypeManip.h"
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// macros TYPELIST_1, TYPELIST_2, ... TYPELIST_50
|
|
||||||
// Each takes a number of arguments equal to its numeric suffix
|
|
||||||
// The arguments are type names. TYPELIST_NN generates a typelist containing
|
|
||||||
// all types passed as arguments, in that order.
|
|
||||||
// Example: TYPELIST_2(char, int) generates a type containing char and int.
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#define TYPELIST_1(T1) ::Loki::Typelist<T1, ::Loki::NullType>
|
|
||||||
|
|
||||||
#define TYPELIST_2(T1, T2) ::Loki::Typelist<T1, TYPELIST_1(T2) >
|
|
||||||
|
|
||||||
#define TYPELIST_3(T1, T2, T3) ::Loki::Typelist<T1, TYPELIST_2(T2, T3) >
|
|
||||||
|
|
||||||
#define TYPELIST_4(T1, T2, T3, T4) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_3(T2, T3, T4) >
|
|
||||||
|
|
||||||
#define TYPELIST_5(T1, T2, T3, T4, T5) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_4(T2, T3, T4, T5) >
|
|
||||||
|
|
||||||
#define TYPELIST_6(T1, T2, T3, T4, T5, T6) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_5(T2, T3, T4, T5, T6) >
|
|
||||||
|
|
||||||
#define TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_6(T2, T3, T4, T5, T6, T7) >
|
|
||||||
|
|
||||||
#define TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_7(T2, T3, T4, T5, T6, T7, T8) >
|
|
||||||
|
|
||||||
#define TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9) >
|
|
||||||
|
|
||||||
#define TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10) >
|
|
||||||
|
|
||||||
#define TYPELIST_11(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_10(T2, T3, T4, T5, T6, T7, T8, T9, T10, T11) >
|
|
||||||
|
|
||||||
#define TYPELIST_12(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_11(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12) >
|
|
||||||
|
|
||||||
#define TYPELIST_13(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_12(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13) >
|
|
||||||
|
|
||||||
#define TYPELIST_14(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_13(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14) >
|
|
||||||
|
|
||||||
#define TYPELIST_15(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_14(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15) >
|
|
||||||
|
|
||||||
#define TYPELIST_16(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_15(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16) >
|
|
||||||
|
|
||||||
#define TYPELIST_17(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_16(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17) >
|
|
||||||
|
|
||||||
#define TYPELIST_18(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_17(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18) >
|
|
||||||
|
|
||||||
#define TYPELIST_19(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_18(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19) >
|
|
||||||
|
|
||||||
#define TYPELIST_20(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_19(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20) >
|
|
||||||
|
|
||||||
#define TYPELIST_21(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_20(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21) >
|
|
||||||
|
|
||||||
#define TYPELIST_22(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_21(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22) >
|
|
||||||
|
|
||||||
#define TYPELIST_23(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_22(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23) >
|
|
||||||
|
|
||||||
#define TYPELIST_24(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_23(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24) >
|
|
||||||
|
|
||||||
#define TYPELIST_25(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_24(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25) >
|
|
||||||
|
|
||||||
#define TYPELIST_26(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_25(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26) >
|
|
||||||
|
|
||||||
#define TYPELIST_27(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_26(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27) >
|
|
||||||
|
|
||||||
#define TYPELIST_28(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_27(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28) >
|
|
||||||
|
|
||||||
#define TYPELIST_29(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_28(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29) >
|
|
||||||
|
|
||||||
#define TYPELIST_30(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_29(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30) >
|
|
||||||
|
|
||||||
#define TYPELIST_31(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_30(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31) >
|
|
||||||
|
|
||||||
#define TYPELIST_32(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_31(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32) >
|
|
||||||
|
|
||||||
#define TYPELIST_33(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_32(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33) >
|
|
||||||
|
|
||||||
#define TYPELIST_34(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_33(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34) >
|
|
||||||
|
|
||||||
#define TYPELIST_35(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_34(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35) >
|
|
||||||
|
|
||||||
#define TYPELIST_36(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_35(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36) >
|
|
||||||
|
|
||||||
#define TYPELIST_37(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_36(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37) >
|
|
||||||
|
|
||||||
#define TYPELIST_38(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_37(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38) >
|
|
||||||
|
|
||||||
#define TYPELIST_39(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_38(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39) >
|
|
||||||
|
|
||||||
#define TYPELIST_40(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_39(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40) >
|
|
||||||
|
|
||||||
#define TYPELIST_41(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_40(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41) >
|
|
||||||
|
|
||||||
#define TYPELIST_42(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_41(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42) >
|
|
||||||
|
|
||||||
#define TYPELIST_43(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_42(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43) >
|
|
||||||
|
|
||||||
#define TYPELIST_44(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_43(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44) >
|
|
||||||
|
|
||||||
#define TYPELIST_45(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_44(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45) >
|
|
||||||
|
|
||||||
#define TYPELIST_46(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45, T46) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_45(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45) >
|
|
||||||
|
|
||||||
#define TYPELIST_47(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45, T46, T47) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_46(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45, T46, T47) >
|
|
||||||
|
|
||||||
#define TYPELIST_48(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45, T46, T47, T48) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_47(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45, T46, T47, T48) >
|
|
||||||
|
|
||||||
#define TYPELIST_49(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45, T46, T47, T48, T49) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_48(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45, T46, T47, T48, T49) >
|
|
||||||
|
|
||||||
#define TYPELIST_50(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45, T46, T47, T48, T49, T50) \
|
|
||||||
::Loki::Typelist<T1, TYPELIST_49(T2, T3, T4, T5, T6, T7, T8, T9, T10, \
|
|
||||||
T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, \
|
|
||||||
T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, \
|
|
||||||
T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, \
|
|
||||||
T41, T42, T43, T44, T45, T46, T47, T48, T49, T50) >
|
|
||||||
|
|
||||||
namespace Loki
|
|
||||||
{
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Typelist
|
|
||||||
// The building block of typelists of any length
|
|
||||||
// Use it through the TYPELIST_NN macros
|
|
||||||
// Defines nested types:
|
|
||||||
// Head (first element, a non-typelist type by convention)
|
|
||||||
// Tail (second element, can be another typelist)
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template <class T, class U>
|
|
||||||
struct Typelist
|
|
||||||
{
|
|
||||||
typedef T Head;
|
|
||||||
typedef U Tail;
|
|
||||||
};
|
|
||||||
|
|
||||||
namespace TL
|
|
||||||
{
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Length
|
|
||||||
// Computes the length of a typelist
|
|
||||||
// Invocation (TList is a typelist):
|
|
||||||
// Length<TList>::value
|
|
||||||
// returns a compile-time constant containing the length of TList, not counting
|
|
||||||
// the end terminator (which by convention is NullType)
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template <class TList> struct Length;
|
|
||||||
template <> struct Length<NullType>
|
|
||||||
{
|
|
||||||
enum { value = 0 };
|
|
||||||
};
|
|
||||||
|
|
||||||
template <class TList>
|
|
||||||
struct Length
|
|
||||||
{
|
|
||||||
enum { value = 1 + Length<typename TList::Tail>::value };
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template TypeAt
|
|
||||||
// Finds the type at a given index in a typelist
|
|
||||||
// Invocation (TList is a typelist and index is a compile-time integral
|
|
||||||
// constant):
|
|
||||||
// TypeAt<TList, index>::Result
|
|
||||||
// returns the type in position 'index' in TList
|
|
||||||
// If you pass an out-of-bounds index, the result is a compile-time error
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
namespace TypeAt_ {
|
|
||||||
|
|
||||||
template<unsigned int i>
|
|
||||||
struct Index {
|
|
||||||
template<class TList>
|
|
||||||
struct Which {
|
|
||||||
typedef typename Index<i - 1>::Which<typename TList::Tail>::Result Result;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct Index<0> {
|
|
||||||
template<class TList>
|
|
||||||
struct Which {
|
|
||||||
typedef typename TList::Head Result;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace TypeAt_
|
|
||||||
|
|
||||||
template<class TList, unsigned int i>
|
|
||||||
struct TypeAt {
|
|
||||||
typedef typename TypeAt_::Index<i>::Which<TList>::Result Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template TypeAtNonStrict
|
|
||||||
// Finds the type at a given index in a typelist
|
|
||||||
// Invocations (TList is a typelist and index is a compile-time integral
|
|
||||||
// constant):
|
|
||||||
// a) TypeAt<TList, index>::Result
|
|
||||||
// returns the type in position 'index' in TList, or NullType if index is
|
|
||||||
// out-of-bounds
|
|
||||||
// b) TypeAt<TList, index, D>::Result
|
|
||||||
// returns the type in position 'index' in TList, or D if index is out-of-bounds
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
namespace TypeAtNonStrict_ {
|
|
||||||
|
|
||||||
template<class TList>
|
|
||||||
struct ListType;
|
|
||||||
|
|
||||||
template<unsigned int index>
|
|
||||||
struct Index;
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct ListType<NullType> {
|
|
||||||
template<unsigned int index, typename DefaultType>
|
|
||||||
struct Remainder {
|
|
||||||
typedef DefaultType Result;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct Index<0> {
|
|
||||||
template<class TList, typename DefaultType>
|
|
||||||
struct Remainder {
|
|
||||||
typedef typename TList::Head Result;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template<unsigned int index>
|
|
||||||
struct Index {
|
|
||||||
template<class TList, typename DefaultType>
|
|
||||||
struct Remainder {
|
|
||||||
enum { isSameType = Conversion<NullType, typename TList::Tail>::sameType };
|
|
||||||
typedef typename Select<isSameType, NullType, typename Index<index - 1>::Remainder<typename TList::Tail, DefaultType>::Result>::Result Result;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class TList>
|
|
||||||
struct ListType {
|
|
||||||
template<unsigned int index, typename DefaultType>
|
|
||||||
struct Remainder {
|
|
||||||
typedef typename Index<index>::Remainder<TList, DefaultType>::Result Result;
|
|
||||||
};
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace TypeAtNonStrict_
|
|
||||||
|
|
||||||
template<class TList, unsigned int index, typename DefaultType = NullType>
|
|
||||||
struct TypeAtNonStrict {
|
|
||||||
typedef typename TypeAtNonStrict_::ListType<TList>::Remainder<index, DefaultType>::Result Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace TL
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template IndexOf
|
|
||||||
// Finds the index of a type in a typelist
|
|
||||||
// Invocation (TList is a typelist and T is a type):
|
|
||||||
// IndexOf<TList, T>::value
|
|
||||||
// returns the position of T in TList, or NullType if T is not found in TList
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
namespace Private {
|
|
||||||
|
|
||||||
namespace IndexOf_ {
|
|
||||||
|
|
||||||
template<typename TList>
|
|
||||||
struct Head {
|
|
||||||
typedef typename TList::Head Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct Head<NullType> {
|
|
||||||
typedef void Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
struct IsNull {
|
|
||||||
enum { value = -1 };
|
|
||||||
};
|
|
||||||
|
|
||||||
struct IsTHead {
|
|
||||||
enum { value = 0 };
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename TList, typename T>
|
|
||||||
struct IsNotTHead {
|
|
||||||
typedef typename TList::Tail Tail;
|
|
||||||
typedef typename Select<is_same<Tail, NullType>::result,
|
|
||||||
IsNull,
|
|
||||||
typename Select<is_same<typename Head<Tail>::Result, T>::result,
|
|
||||||
IsTHead, IsNotTHead<Tail, T>
|
|
||||||
>::Result
|
|
||||||
>::Result chooser;
|
|
||||||
enum { temp = chooser::value };
|
|
||||||
enum { value = temp == -1 ? -1 : 1 + temp };
|
|
||||||
};
|
|
||||||
|
|
||||||
template<typename TList, typename T>
|
|
||||||
struct IsNotNull {
|
|
||||||
typedef typename Select<is_same<typename TList::Head, T>::result,
|
|
||||||
IsTHead,
|
|
||||||
IsNotTHead<TList, T>
|
|
||||||
>::Result chooser;
|
|
||||||
enum { value = chooser::value };
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace IndexOf_
|
|
||||||
|
|
||||||
} // namespace Private
|
|
||||||
|
|
||||||
namespace TL {
|
|
||||||
|
|
||||||
template<class TList, class T>
|
|
||||||
struct IndexOf {
|
|
||||||
private:
|
|
||||||
typedef typename Select<Private::is_same<TList, NullType>::result,
|
|
||||||
Private::IndexOf_::IsNull,
|
|
||||||
Private::IndexOf_::IsNotNull<TList, T>
|
|
||||||
>::Result chooser;
|
|
||||||
public:
|
|
||||||
enum { value = chooser::value };
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Append
|
|
||||||
// Appends a type or a typelist to another
|
|
||||||
// Invocation (TList is a typelist and T is either a type or a typelist):
|
|
||||||
// Append<TList, T>::Result
|
|
||||||
// returns a typelist that is TList followed by T and NullType-terminated
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
namespace Append_ {
|
|
||||||
|
|
||||||
template<class T>
|
|
||||||
struct Helper {
|
|
||||||
struct big { char i[2]; };
|
|
||||||
template<class Head, class Tail>
|
|
||||||
static char Test(const Typelist<Head, Tail>&);
|
|
||||||
static big Test(...);
|
|
||||||
static T makeT();
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace Append_
|
|
||||||
|
|
||||||
template<class TList, class T>
|
|
||||||
struct Append;
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct Append<NullType, NullType> {
|
|
||||||
typedef NullType Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class TList, class T>
|
|
||||||
struct Append {
|
|
||||||
private:
|
|
||||||
enum { T_is_list = sizeof(Append_::Helper<T>::Test(Append_::Helper<T>::MakeT())) == sizeof(char) };
|
|
||||||
enum { TList_is_null = Conversion<TList, NullType>::sameType };
|
|
||||||
typedef typename Select<TList_is_null & T_is_list, T, NullType>::Result Result1;
|
|
||||||
typedef typename Select<TList_is_null & !T_is_list, Typelist<T, NullType>, Result1>::Result Result2;
|
|
||||||
public:
|
|
||||||
typedef typename Select<!TList_is_null & !T_is_list, Typelist<typename TList::Head, typename Append<typename TList::Tail, T>::Result>, Result2>::Result Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Erase
|
|
||||||
// Erases the first occurence, if any, of a type in a typelist
|
|
||||||
// Invocation (TList is a typelist and T is a type):
|
|
||||||
// Erase<TList, T>::Result
|
|
||||||
// returns a typelist that is TList without the first occurence of T
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template<class TList, class T>
|
|
||||||
struct Erase {
|
|
||||||
private:
|
|
||||||
enum { TList_is_null = Conversion<TList, NullType>::sameType };
|
|
||||||
enum { Head_is_T = Conversion<typename TList::Head, T>::sameType };
|
|
||||||
typedef typename Select<!TList_is_null & Head_is_T, typename TList::Tail, NullType>::Result Result1;
|
|
||||||
public:
|
|
||||||
typedef typename Select<!TList_is_null & !Head_is_T, Typelist<typename TList::Head, typename Erase<typename TList::Tail, T>::Result>, Result1>::Result Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template EraseAll
|
|
||||||
// Erases all first occurences, if any, of a type in a typelist
|
|
||||||
// Invocation (TList is a typelist and T is a type):
|
|
||||||
// EraseAll<TList, T>::Result
|
|
||||||
// returns a typelist that is TList without any occurence of T
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template<class TList, class T>
|
|
||||||
struct EraseAll {
|
|
||||||
private:
|
|
||||||
enum { TList_is_null = Conversion<TList, NullType>::sameType };
|
|
||||||
enum { Head_is_T = Conversion<typename TList::Head, T>::sameType };
|
|
||||||
typedef typename Select<!TList_is_null & Head_is_T, typename EraseAll<typename TList::Tail, T>::Result, NullType>::Result Result1;
|
|
||||||
public:
|
|
||||||
typedef typename Select<!TList_is_null & !Head_is_T, Typelist<typename TList::Head, typename EraseAll<typename TList::Tail, T>::Result>, Result1>::Result Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template NoDuplicates
|
|
||||||
// Removes all duplicate types in a typelist
|
|
||||||
// Invocation (TList is a typelist):
|
|
||||||
// NoDuplicates<TList, T>::Result
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template<class TList>
|
|
||||||
struct NoDuplicates;
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct NoDuplicates<NullType> {
|
|
||||||
typedef NullType Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class TList>
|
|
||||||
struct NoDuplicates {
|
|
||||||
private:
|
|
||||||
typedef typename NoDuplicates<typename TList::Tail>::Result L1;
|
|
||||||
typedef typename Erase<L1, typename TList::Head>::Result L2;
|
|
||||||
public:
|
|
||||||
typedef Typelist<typename TList::Head, L2> Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Replace
|
|
||||||
// Replaces the first occurence of a type in a typelist, with another type
|
|
||||||
// Invocation (TList is a typelist, T, U are types):
|
|
||||||
// Replace<TList, T, U>::Result
|
|
||||||
// returns a typelist in which the first occurence of T is replaced with U
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template<class TList, class T, class U>
|
|
||||||
struct Replace {
|
|
||||||
private:
|
|
||||||
enum { TList_is_null = Conversion<TList, NullType>::sameType };
|
|
||||||
enum { Head_is_T = Conversion<typename TList::Head, T>::sameType };
|
|
||||||
typedef typename Select<!TList_is_null & Head_is_T, Typelist<U, typename TList::Tail>, NullType>::Result Result1;
|
|
||||||
public:
|
|
||||||
typedef typename Select<!TList_is_null & !Head_is_T, Typelist<typename TList::Head, typename Replace<typename TList::Tail, T, U>::Result>, Result1>::Result Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template ReplaceAll
|
|
||||||
// Replaces all occurences of a type in a typelist, with another type
|
|
||||||
// Invocation (TList is a typelist, T, U are types):
|
|
||||||
// Replace<TList, T, U>::Result
|
|
||||||
// returns a typelist in which all occurences of T is replaced with U
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template<class TList, class T, class U>
|
|
||||||
struct ReplaceAll {
|
|
||||||
private:
|
|
||||||
enum { TList_is_null = Conversion<TList, NullType>::sameType };
|
|
||||||
enum { Head_is_T = Conversion<typename TList::Head, T>::sameType };
|
|
||||||
typedef typename Select<!TList_is_null & Head_is_T, Typelist<U, typename ReplaceAll<typename TList::Tail, T, U>::Result>, NullType>::Result Result1;
|
|
||||||
public:
|
|
||||||
typedef typename Select<!TList_is_null & !Head_is_T, Typelist<typename TList::Head, typename ReplaceAll<typename TList::Tail, T, U>::Result>, Result1>::Result Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template Reverse
|
|
||||||
// Reverses a typelist
|
|
||||||
// Invocation (TList is a typelist):
|
|
||||||
// Reverse<TList>::Result
|
|
||||||
// returns a typelist that is TList reversed
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template<class TList>
|
|
||||||
struct Reverse {
|
|
||||||
private:
|
|
||||||
enum { list_of_one = Conversion<typename TList::Tail, NullType>::sameType };
|
|
||||||
public:
|
|
||||||
typedef typename Select<list_of_one,
|
|
||||||
TList,
|
|
||||||
typename Append<typename Reverse<typename TList::Tail>::Result,
|
|
||||||
typename TList::Head
|
|
||||||
>::Result
|
|
||||||
>::Result Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template MostDerived
|
|
||||||
// Finds the type in a typelist that is the most derived from a given type
|
|
||||||
// Invocation (TList is a typelist, T is a type):
|
|
||||||
// Replace<TList, T>::Result
|
|
||||||
// returns the type in TList that's the most derived from T
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
template<class TList, class T>
|
|
||||||
struct MostDerived {
|
|
||||||
private:
|
|
||||||
enum { TList_is_null = Conversion<TList, NullType>::sameType };
|
|
||||||
typedef typename Select<TList_is_null, T, typename MostDerived<typename TList::Tail, T>::Result>::Result Candidate;
|
|
||||||
public:
|
|
||||||
typedef typename Select<TList_is_null, T,
|
|
||||||
typename Select<SUPERSUBCLASS(Candidate, typename TList::Head),
|
|
||||||
typename TList::Head, Candidate
|
|
||||||
>::Result
|
|
||||||
>::Result Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// class template DerivedToFront
|
|
||||||
// Arranges the types in a typelist so that the most derived types appear first
|
|
||||||
// Invocation (TList is a typelist):
|
|
||||||
// DerivedToFront<TList>::Result
|
|
||||||
// returns the reordered TList
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
namespace DerivedToFront_ {
|
|
||||||
|
|
||||||
template<class TList>
|
|
||||||
struct ListType {
|
|
||||||
};
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct ListType<NullType> {
|
|
||||||
typedef NullType Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace DerivedToFront_
|
|
||||||
|
|
||||||
template<class TList>
|
|
||||||
struct DerivedToFront;
|
|
||||||
|
|
||||||
template<>
|
|
||||||
struct DerivedToFront<NullType> {
|
|
||||||
typedef NullType Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
template<class TList>
|
|
||||||
struct DerivedToFront {
|
|
||||||
private:
|
|
||||||
typedef typename MostDerived<typename TList::Tail,
|
|
||||||
typename TList::Head>::Result TheMostDerived;
|
|
||||||
typedef typename Replace<typename TList::Tail, TheMostDerived,
|
|
||||||
typename TList::Head>::Result L;
|
|
||||||
public:
|
|
||||||
typedef Typelist<TheMostDerived, L> Result;
|
|
||||||
};
|
|
||||||
|
|
||||||
} // namespace TL
|
|
||||||
|
|
||||||
} // namespace Loki
|
|
||||||
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
// Change log:
|
|
||||||
// June 09, 2001: Fix bug in parameter list of macros TYPELIST_23 to TYPELIST_27
|
|
||||||
// (credit due to Dave Taylor)
|
|
||||||
// June 20, 2001: ported by Nick Thurn to gcc 2.95.3. Kudos, Nick!!!
|
|
||||||
// August 22, 2001: ported by Jonathan H Lundquist to MSVC
|
|
||||||
////////////////////////////////////////////////////////////////////////////////
|
|
||||||
|
|
||||||
#endif // TYPELIST_INC_
|
|
||||||
Loading…
Add table
Add a link
Reference in a new issue