x
Yes
No
Do you want to visit DriveHQ English website?
Inicio
Características
Precios
Prueba gratuita
Software cliente
Acerca de nosotros
Servidor de archivos
|
Solución de copias de seguridad
|
Servidor FTP
|
Servidor de correo electrónico
|
Alojamiento web
|
Software cliente
Servidor de archivos
Solución de copia de seguridad
Servidor FTP
Servidor de correo electrónico
Alojamiento web
Software cliente
tuple_comparison.hpp - Hosted on DriveHQ Cloud IT Platform
Arriba
Subir
Descargar
Compartir
Publicar
Nueva carpeta
Nuevo archivo
Copiar
Cortar
Eliminar
Pegar
Clasificación
Actualizar
Ruta de la carpeta: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\tuple\tuple_comparison.hpp
Girar
Efecto
Propiedad
Historial
// tuple_comparison.hpp ----------------------------------------------------- // // Copyright (C) 2001 Jaakko J�rvi (jaakko.jarvi@cs.utu.fi) // Copyright (C) 2001 Gary Powell (gary.powell@sierra.com) // // 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) // // For more information, see http://www.boost.org // // (The idea and first impl. of comparison operators was from Doug Gregor) // ----------------------------------------------------------------- #ifndef BOOST_TUPLE_COMPARISON_HPP #define BOOST_TUPLE_COMPARISON_HPP #include "boost/tuple/tuple.hpp" // ------------------------------------------------------------- // equality and comparison operators // // == and != compare tuples elementwise // <, >, <= and >= use lexicographical ordering // // Any operator between tuples of different length fails at compile time // No dependencies between operators are assumed // (i.e. !(a
=b, a!=b does not imply a==b etc. // so any weirdnesses of elementary operators are respected). // // ------------------------------------------------------------- namespace boost { namespace tuples { inline bool operator==(const null_type&, const null_type&) { return true; } inline bool operator>=(const null_type&, const null_type&) { return true; } inline bool operator<=(const null_type&, const null_type&) { return true; } inline bool operator!=(const null_type&, const null_type&) { return false; } inline bool operator<(const null_type&, const null_type&) { return false; } inline bool operator>(const null_type&, const null_type&) { return false; } namespace detail { // comparison operators check statically the length of its operands and // delegate the comparing task to the following functions. Hence // the static check is only made once (should help the compiler). // These functions assume tuples to be of the same length. template
inline bool eq(const T1& lhs, const T2& rhs) { return lhs.get_head() == rhs.get_head() && eq(lhs.get_tail(), rhs.get_tail()); } template<> inline bool eq
(const null_type&, const null_type&) { return true; } template
inline bool neq(const T1& lhs, const T2& rhs) { return lhs.get_head() != rhs.get_head() || neq(lhs.get_tail(), rhs.get_tail()); } template<> inline bool neq
(const null_type&, const null_type&) { return false; } template
inline bool lt(const T1& lhs, const T2& rhs) { return lhs.get_head() < rhs.get_head() || !(rhs.get_head() < lhs.get_head()) && lt(lhs.get_tail(), rhs.get_tail()); } template<> inline bool lt
(const null_type&, const null_type&) { return false; } template
inline bool gt(const T1& lhs, const T2& rhs) { return lhs.get_head() > rhs.get_head() || !(rhs.get_head() > lhs.get_head()) && gt(lhs.get_tail(), rhs.get_tail()); } template<> inline bool gt
(const null_type&, const null_type&) { return false; } template
inline bool lte(const T1& lhs, const T2& rhs) { return lhs.get_head() <= rhs.get_head() && ( !(rhs.get_head() <= lhs.get_head()) || lte(lhs.get_tail(), rhs.get_tail())); } template<> inline bool lte
(const null_type&, const null_type&) { return true; } template
inline bool gte(const T1& lhs, const T2& rhs) { return lhs.get_head() >= rhs.get_head() && ( !(rhs.get_head() >= lhs.get_head()) || gte(lhs.get_tail(), rhs.get_tail())); } template<> inline bool gte
(const null_type&, const null_type&) { return true; } } // end of namespace detail // equal ---- template
inline bool operator==(const cons
& lhs, const cons
& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length
::value == length
::value); return detail::eq(lhs, rhs); } // not equal ----- template
inline bool operator!=(const cons
& lhs, const cons
& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length
::value == length
::value); return detail::neq(lhs, rhs); } // < template
inline bool operator<(const cons
& lhs, const cons
& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length
::value == length
::value); return detail::lt(lhs, rhs); } // > template
inline bool operator>(const cons
& lhs, const cons
& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length
::value == length
::value); return detail::gt(lhs, rhs); } // <= template
inline bool operator<=(const cons
& lhs, const cons
& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length
::value == length
::value); return detail::lte(lhs, rhs); } // >= template
inline bool operator>=(const cons
& lhs, const cons
& rhs) { // check that tuple lengths are equal BOOST_STATIC_ASSERT(length
::value == length
::value); return detail::gte(lhs, rhs); } } // end of namespace tuples } // end of namespace boost #endif // BOOST_TUPLE_COMPARISON_HPP
tuple_comparison.hpp
Dirección de la página
Dirección del archivo
Anterior
2/3
Siguiente
Descargar
( 5 KB )
Comments
Total ratings:
0
Average rating:
No clasificado
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.