mirror/Aquaria
1
0
Fork 0
mirror of https://github.com/AquariaOSE/Aquaria.git synced 2025-10-04 21:34:41 +00:00
Code Issues Releases Wiki Activity

initial commit. This is icculus version 5542b94cae02a6333845854bbbd1abe0a259f1a4

Browse source
This commit is contained in:
fgenesis 2011-08-03 22:05:33 +02:00
commit 3096eaf5e2
2519 changed files with 816064 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

180
BBGE/flags.hpp Normal file
View file

@ -0,0 +1,180 @@
// flags.hpp
//
// Copyright (c) 2004 Eugene Gladyshev
//
// Permission to copy, use, modify, sell and distribute this software
// is granted provided this copyright notice appears in all copies.
// This software is provided "as is" without express or implied
// warranty, and with no claim as to its suitability for any purpose.
//
#ifndef __ttl_flg_flags__hpp
#define __ttl_flg_flags__hpp
#include <algorithm>
namespace ttl
{
namespace flg
{
namespace impl
{
template<
int Bits,
int type = Bits <= sizeof(char)*8?1:(Bits <= sizeof(short)*8?2:(Bits <= sizeof(int)*8?3:4))
> struct bestfit;
template< int Bits >
struct bestfit<Bits, 1>
{
typedef unsigned char type;
};
template< int Bits >
struct bestfit<Bits, 2>
{
typedef unsigned short type;
};
template< int Bits >
struct bestfit<Bits, 3>
{
typedef unsigned int type;
};
template< int Bits >
struct bestfit<Bits, 4>
{
typedef unsigned int type;
};
};
template< typename T, int Bits = sizeof(int)*8, typename Holder = typename impl::bestfit<Bits>::type >
struct flags
{
typedef flags this_t;
typedef T value_type;
Holder f_;
flags() : f_(0) {}
flags( T f1 ) : f_(f1) {}
flags( T f1, T f2 ) : f_(f1|f2) {}
flags( T f1, T f2, T f3 ) : f_(f1|f2|f3) {}
flags( T f1, T f2, T f3, T f4 ) : f_(f1|f2|f3|f4) {}
flags( T f1, T f2, T f3, T f4, T f5 ) : f_(f1|f2|f3|f4|f5) {}
flags( T f1, T f2, T f3, T f4, T f5, T f6 ) : f_(f1|f2|f3|f4|f5|f6) {}
flags( T f1, T f2, T f3, T f4, T f5, T f6, T f7 ) : f_(f1|f2|f3|f4|f5|f6|f7) {}
flags( T f1, T f2, T f3, T f4, T f5, T f6, T f7, T f8 ) : f_(f1|f2|f3|f4|f5|f6|f7|f8) {}
flags( T f1, T f2, T f3, T f4, T f5, T f6, T f7, T f8, T f9 ) : f_(f1|f2|f3|f4|f5|f6|f7|f8|f9) {}
flags( T f1, T f2, T f3, T f4, T f5, T f6, T f7, T f8, T f9, T f10 ) : f_(f1|f2|f3|f4|f5|f6|f7|f8|f9|f10) {}
this_t& operator |=( const this_t& f ) { f_ |= f.f_; return *this; }
this_t& operator &=( const this_t& f ) { f_ &= f.f_; return *this; }
bool operator ==( const this_t& l ) const { return f_ == l.f_; }
bool operator !=( const this_t& l ) const { return f_ != l.f_; }
bool operator !() { return f_ == 0; }
Holder get_holder() const { return f_; }
bool test( const this_t l ) const { return (f_ & l.f_)?true:false; }
bool test() const { return f_!=0; }
};
template< typename T, int Bits, typename Holder >
flags<T, Bits, Holder> operator ~(const flags<T, Bits, Holder>& l)
{
flags<T, Bits, Holder> tmp;
tmp.f_ = ~l.f_;
return tmp;
}
template< typename T, int Bits, typename Holder >
flags<T, Bits, Holder> operator |(const flags<T, Bits, Holder>& l, const T& r)
{
flags<T, Bits, Holder> tmp( r );
return l|tmp;
}
template< typename T, int Bits, typename Holder >
flags<T, Bits, Holder> operator |(const flags<T, Bits, Holder>& l, const flags<T, Bits, Holder>& r)
{
flags<T, Bits, Holder> tmp( l );
tmp|=r;
return tmp;
}
template< typename T, int Bits, typename Holder >
flags<T, Bits, Holder> operator &(const flags<T, Bits, Holder>& l, const T& r)
{
flags<T, Bits, Holder> tmp( r );
return l&tmp;
}
template< typename T, int Bits, typename Holder >
flags<T, Bits, Holder> operator &(const flags<T, Bits, Holder>& l, const flags<T, Bits, Holder>& r)
{
flags<T, Bits, Holder> tmp( l );
tmp&=r;
return tmp;
}
struct map_first2second {};
struct map_second2first {};
template < typename Pair, typename MapDirection = map_first2second >
struct flag_mapper;
template< typename Pair >
struct flag_mapper<Pair, map_first2second>
{
typedef typename Pair::first_type type;
typedef typename Pair::second_type result_type;
const type& d_;
result_type& r_;
flag_mapper( const type& d, result_type& r ) : d_(d), r_(r) {}
void operator()( const Pair& p ) const
{
if( (p.first&d_) == true ) r_ |= p.second;
}
};
template< typename Pair >
struct flag_mapper<Pair, map_second2first>
{
typedef typename Pair::second_type type;
typedef typename Pair::first_type result_type;
const type& d_;
result_type r_;
flag_mapper( const type& d ) : d_(d), r_() {}
void operator()( const Pair& p ) const
{
if( (p.second&d_) == true ) r_ |= p.first;
}
};
//It is a an iterator of elements like std::pair
template< typename It >
typename It::value_type::second_type map(
const typename It::value_type::first_type f,
It first, It end )
{
typename It::value_type::second_type r;
flag_mapper<typename It::value_type> m(f, r);
std::for_each( first, end, m );
return r;
}
}; //flg
};
#endif //__flags__hpp