test_sort_all_parameters.h

/***************************************************************************
 * algo/test_sort_all_parameters.h
 *
 * Part of the STXXL. See http://stxxl.sourceforge.net
 *
 * Copyright (C) 2002 Roman Dementiev <[email protected]>
 * Copyright (C) 2008, 2009 Andreas Beckmann <[email protected]>
 *
 * Distributed under the Boost Software License, Version 1.0.
 * (See accompanying file LICENSE_1_0.txt or copy at
 * http://www.boost.org/LICENSE_1_0.txt)
 **************************************************************************/

#include <limits>
#include <stxxl/types>

template <unsigned n>
struct bulk
{
 char _data[n];
};

template <>
struct bulk<0>
{ };

template <typename KEY, unsigned SIZE>
struct my_type
{
 typedef KEY key_type;

 key_type _key;
 bulk<SIZE - sizeof(key_type)> _data;

 my_type() { }
 my_type(key_type __key) : _key(__key) { }

#ifdef KEY_COMPARE
 key_type key() const
 {
 return _key;
 }
#endif

 static my_type<KEY, SIZE> min_value()
 {
 return my_type<KEY, SIZE>(std::numeric_limits<key_type>::min());
 }
 static my_type<KEY, SIZE> max_value()
 {
 return my_type<KEY, SIZE>(std::numeric_limits<key_type>::max());
 }
};

template <typename KEY, unsigned SIZE>
std::ostream & operator << (std::ostream & o, const my_type<KEY, SIZE> obj)
{
#ifndef KEY_COMPARE
 o << obj._key;
#else
 o << obj.key();
#endif
 return o;
}

#ifndef KEY_COMPARE

template <typename KEY, unsigned SIZE>
bool operator < (const my_type<KEY, SIZE> & a, const my_type<KEY, SIZE> & b)
{
 return a._key < b._key;
}

template <typename KEY, unsigned SIZE>
bool operator == (const my_type<KEY, SIZE> & a, const my_type<KEY, SIZE> & b)
{
 return a._key == b._key;
}

template <typename KEY, unsigned SIZE>
bool operator != (const my_type<KEY, SIZE> & a, const my_type<KEY, SIZE> & b)
{
 return a._key != b._key;
}

template <typename T>
struct Cmp : public std::less<T>
{
 bool operator () (const T & a, const T & b) const
 {
 return a._key < b._key;
 }

 static T min_value()
 {
 return T::min_value();
 }
 static T max_value()
 {
 return T::max_value();
 }
};

#else

template <typename KEY, unsigned SIZE>
bool operator < (const my_type<KEY, SIZE> & a, const my_type<KEY, SIZE> & b)
{
 return a.key() < b.key();
}

#endif

struct zero
{
 unsigned operator () ()
 {
 return 0;
 }
};