Gered
c5cdddbeaa
current versions of all of my basic framework sources, build configurations/scripts, and supporting assets
1778 lines
50 KiB
C++
1778 lines
50 KiB
C++
/*
|
|
Copyright (C) 2005,2009-2010 Electronic Arts, Inc. All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions
|
|
are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright
|
|
notice, this list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright
|
|
notice, this list of conditions and the following disclaimer in the
|
|
documentation and/or other materials provided with the distribution.
|
|
3. Neither the name of Electronic Arts, Inc. ("EA") nor the names of
|
|
its contributors may be used to endorse or promote products derived
|
|
from this software without specific prior written permission.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY ELECTRONIC ARTS AND ITS CONTRIBUTORS "AS IS" AND ANY
|
|
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL ELECTRONIC ARTS OR ITS CONTRIBUTORS BE LIABLE FOR ANY
|
|
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
|
|
THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// EASTL/bitset.h
|
|
//
|
|
// Written and maintained by Paul Pedriana - 2005.
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// This file implements a bitset much like the C++ std::bitset class.
|
|
// The primary distinctions between this list and std::bitset are:
|
|
// - bitset is more efficient than some other std::bitset implementations,
|
|
// - bitset is savvy to an environment that doesn't have exception handling,
|
|
// as is sometimes the case with console or embedded environments.
|
|
// - bitset is savvy to environments in which 'unsigned long' is not the
|
|
// most efficient integral data type. std::bitset implementations use
|
|
// unsigned long, even if it is an inefficient integer type.
|
|
// - bitset removes as much function calls as practical, in order to allow
|
|
// debug builds to run closer in speed and code footprint to release builds.
|
|
// - bitset doesn't support string functionality. We can add this if
|
|
// it is deemed useful.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
#ifndef EASTL_BITSET_H
|
|
#define EASTL_BITSET_H
|
|
|
|
|
|
#include <EASTL/internal/config.h>
|
|
#include <EASTL/algorithm.h>
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(push, 0)
|
|
#endif
|
|
#include <stddef.h>
|
|
#ifdef __MWERKS__
|
|
#include <../Include/string.h> // Force the compiler to use the std lib header.
|
|
#else
|
|
#include <string.h>
|
|
#endif
|
|
#ifdef _MSC_VER
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
#if EASTL_EXCEPTIONS_ENABLED
|
|
#ifdef _MSC_VER
|
|
#pragma warning(push, 0)
|
|
#endif
|
|
#include <stdexcept> // std::out_of_range, std::length_error.
|
|
#ifdef _MSC_VER
|
|
#pragma warning(pop)
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(push)
|
|
#pragma warning(disable: 4127) // Conditional expression is constant
|
|
#elif defined(__SNC__)
|
|
#pragma control %push diag
|
|
#pragma diag_suppress=187 // Pointless comparison of unsigned integer with zero
|
|
#endif
|
|
|
|
|
|
namespace eastl
|
|
{
|
|
|
|
/// BitsetWordType
|
|
///
|
|
/// Defines the integral data type used by bitset.
|
|
/// The C++ standard specifies that the std::bitset word type be unsigned long,
|
|
/// but that isn't necessarily the most efficient data type for the given platform.
|
|
/// We can follow the standard and be potentially less efficient or we can do what
|
|
/// is more efficient but less like the C++ std::bitset.
|
|
///
|
|
#if(EA_PLATFORM_WORD_SIZE == 4)
|
|
typedef uint32_t BitsetWordType;
|
|
const uint32_t kBitsPerWord = 32;
|
|
const uint32_t kBitsPerWordMask = 31;
|
|
const uint32_t kBitsPerWordShift = 5;
|
|
#else
|
|
typedef uint64_t BitsetWordType;
|
|
const uint32_t kBitsPerWord = 64;
|
|
const uint32_t kBitsPerWordMask = 63;
|
|
const uint32_t kBitsPerWordShift = 6;
|
|
#endif
|
|
|
|
|
|
|
|
/// BITSET_WORD_COUNT
|
|
///
|
|
/// Defines the number of words we use, based on the number of bits.
|
|
///
|
|
#if !defined(__GNUC__) || (__GNUC__ >= 3) // GCC 2.x can't handle the simpler declaration below.
|
|
#define BITSET_WORD_COUNT(nBitCount) (N == 0 ? 1 : ((N - 1) / (8 * sizeof(BitsetWordType)) + 1))
|
|
#else
|
|
#define BITSET_WORD_COUNT(nBitCount) ((N - 1) / (8 * sizeof(BitsetWordType)) + 1)
|
|
#endif
|
|
|
|
|
|
|
|
/// BitsetBase
|
|
///
|
|
/// This is a default implementation that works for any number of words.
|
|
///
|
|
template <size_t NW> // Templated on the number of words used to hold the bitset.
|
|
struct BitsetBase
|
|
{
|
|
typedef BitsetWordType word_type;
|
|
typedef BitsetBase<NW> this_type;
|
|
#if EASTL_BITSET_SIZE_T
|
|
typedef size_t size_type;
|
|
#else
|
|
typedef eastl_size_t size_type;
|
|
#endif
|
|
|
|
public:
|
|
word_type mWord[NW];
|
|
|
|
public:
|
|
BitsetBase();
|
|
BitsetBase(uint32_t value);
|
|
|
|
void operator&=(const this_type& x);
|
|
void operator|=(const this_type& x);
|
|
void operator^=(const this_type& x);
|
|
|
|
void operator<<=(size_type n);
|
|
void operator>>=(size_type n);
|
|
|
|
void flip();
|
|
void set();
|
|
void set(size_type i, bool value);
|
|
void reset();
|
|
|
|
bool operator==(const this_type& x) const;
|
|
|
|
bool any() const;
|
|
size_type count() const;
|
|
|
|
unsigned long to_ulong() const;
|
|
|
|
word_type& DoGetWord(size_type i);
|
|
word_type DoGetWord(size_type i) const;
|
|
|
|
size_type DoFindFirst() const;
|
|
size_type DoFindNext(size_type last_find) const;
|
|
|
|
size_type DoFindLast() const;
|
|
size_type DoFindPrev(size_type last_find) const;
|
|
|
|
}; // class BitsetBase
|
|
|
|
|
|
|
|
/// BitsetBase<1>
|
|
///
|
|
/// This is a specialization for a bitset that fits within one word.
|
|
///
|
|
template <>
|
|
struct BitsetBase<1>
|
|
{
|
|
typedef BitsetWordType word_type;
|
|
typedef BitsetBase<1> this_type;
|
|
#if EASTL_BITSET_SIZE_T
|
|
typedef size_t size_type;
|
|
#else
|
|
typedef eastl_size_t size_type;
|
|
#endif
|
|
|
|
public:
|
|
word_type mWord[1]; // Defined as an array of 1 so that bitset can treat this BitsetBase like others.
|
|
|
|
public:
|
|
BitsetBase();
|
|
BitsetBase(uint32_t value);
|
|
|
|
void operator&=(const this_type& x);
|
|
void operator|=(const this_type& x);
|
|
void operator^=(const this_type& x);
|
|
|
|
void operator<<=(size_type n);
|
|
void operator>>=(size_type n);
|
|
|
|
void flip();
|
|
void set();
|
|
void set(size_type i, bool value);
|
|
void reset();
|
|
|
|
bool operator==(const this_type& x) const;
|
|
|
|
bool any() const;
|
|
size_type count() const;
|
|
|
|
unsigned long to_ulong() const;
|
|
|
|
word_type& DoGetWord(size_type);
|
|
word_type DoGetWord(size_type) const;
|
|
|
|
size_type DoFindFirst() const;
|
|
size_type DoFindNext(size_type last_find) const;
|
|
|
|
size_type DoFindLast() const;
|
|
size_type DoFindPrev(size_type last_find) const;
|
|
|
|
}; // BitsetBase<1>
|
|
|
|
|
|
|
|
/// BitsetBase<2>
|
|
///
|
|
/// This is a specialization for a bitset that fits within two words.
|
|
/// The difference here is that we avoid branching (ifs and loops).
|
|
///
|
|
template <>
|
|
struct BitsetBase<2>
|
|
{
|
|
typedef BitsetWordType word_type;
|
|
typedef BitsetBase<2> this_type;
|
|
#if EASTL_BITSET_SIZE_T
|
|
typedef size_t size_type;
|
|
#else
|
|
typedef eastl_size_t size_type;
|
|
#endif
|
|
|
|
public:
|
|
word_type mWord[2];
|
|
|
|
public:
|
|
BitsetBase();
|
|
BitsetBase(uint32_t value);
|
|
|
|
void operator&=(const this_type& x);
|
|
void operator|=(const this_type& x);
|
|
void operator^=(const this_type& x);
|
|
|
|
void operator<<=(size_type n);
|
|
void operator>>=(size_type n);
|
|
|
|
void flip();
|
|
void set();
|
|
void set(size_type i, bool value);
|
|
void reset();
|
|
|
|
bool operator==(const this_type& x) const;
|
|
|
|
bool any() const;
|
|
size_type count() const;
|
|
|
|
unsigned long to_ulong() const;
|
|
|
|
word_type& DoGetWord(size_type);
|
|
word_type DoGetWord(size_type) const;
|
|
|
|
size_type DoFindFirst() const;
|
|
size_type DoFindNext(size_type last_find) const;
|
|
|
|
size_type DoFindLast() const;
|
|
size_type DoFindPrev(size_type last_find) const;
|
|
|
|
}; // BitsetBase<2>
|
|
|
|
|
|
|
|
|
|
/// bitset
|
|
///
|
|
/// Implements a bitset much like the C++ std::bitset.
|
|
///
|
|
/// As of this writing we don't have an implementation of bitset<0>,
|
|
/// as it is deemed an academic exercise that nobody should actually
|
|
/// use and it would increase code space.
|
|
///
|
|
/// Note: bitset shifts of a magnitude >= sizeof(BitsetWordType)
|
|
/// (e.g. shift of 32 on a 32 bit system) are not guaranteed to work
|
|
/// properly. This is because some systems (e.g. Intel x86) take the
|
|
/// shift value and mod it to the word size and thus a shift of 32
|
|
/// can become a shift of 0 on a 32 bit system. We don't attempt to
|
|
/// resolve this behaviour in this class because doing so would lead
|
|
/// to a less efficient implementation and the vast majority of the
|
|
/// time the user doesn't do shifts of >= word size. You can work
|
|
/// around this by implementing a shift of 32 as two shifts of 16.
|
|
///
|
|
template <size_t N>
|
|
class bitset : private BitsetBase<BITSET_WORD_COUNT(N)>
|
|
{
|
|
public:
|
|
typedef BitsetBase<BITSET_WORD_COUNT(N)> base_type;
|
|
typedef bitset<N> this_type;
|
|
typedef BitsetWordType word_type;
|
|
typedef typename base_type::size_type size_type;
|
|
|
|
enum
|
|
{
|
|
kSize = N,
|
|
kWordCount = BITSET_WORD_COUNT(N),
|
|
kNW = kWordCount // This name is deprecated.
|
|
};
|
|
|
|
using base_type::mWord;
|
|
using base_type::DoGetWord;
|
|
using base_type::DoFindFirst;
|
|
using base_type::DoFindNext;
|
|
using base_type::DoFindLast;
|
|
using base_type::DoFindPrev;
|
|
|
|
public:
|
|
/// reference
|
|
///
|
|
/// A reference is a reference to a specific bit in the bitset.
|
|
/// The C++ standard specifies that this be a nested class,
|
|
/// though it is not clear if a non-nested reference implementation
|
|
/// would be non-conforming.
|
|
///
|
|
class reference
|
|
{
|
|
protected:
|
|
friend class bitset;
|
|
|
|
word_type* mpBitWord;
|
|
size_type mnBitIndex;
|
|
|
|
reference(){} // The C++ standard specifies that this is private.
|
|
|
|
public:
|
|
reference(const bitset& x, size_type i);
|
|
|
|
reference& operator=(bool value);
|
|
reference& operator=(const reference& x);
|
|
|
|
bool operator~() const;
|
|
operator bool() const // Defined inline because CodeWarrior fails to be able to compile it outside.
|
|
{ return (*mpBitWord & (static_cast<word_type>(1) << (mnBitIndex & kBitsPerWordMask))) != 0; }
|
|
|
|
reference& flip();
|
|
};
|
|
|
|
public:
|
|
friend class reference;
|
|
|
|
bitset();
|
|
bitset(uint32_t value);
|
|
|
|
// We don't define copy constructor and operator= because
|
|
// the compiler-generated versions will suffice.
|
|
|
|
this_type& operator&=(const this_type& x);
|
|
this_type& operator|=(const this_type& x);
|
|
this_type& operator^=(const this_type& x);
|
|
|
|
this_type& operator<<=(size_type n);
|
|
this_type& operator>>=(size_type n);
|
|
|
|
this_type& set();
|
|
this_type& set(size_type i, bool value = true);
|
|
|
|
this_type& reset();
|
|
this_type& reset(size_type i);
|
|
|
|
this_type& flip();
|
|
this_type& flip(size_type i);
|
|
this_type operator~() const;
|
|
|
|
reference operator[](size_type i);
|
|
bool operator[](size_type i) const;
|
|
|
|
const word_type* data() const;
|
|
word_type* data();
|
|
|
|
unsigned long to_ulong() const;
|
|
|
|
size_type count() const;
|
|
size_type size() const;
|
|
|
|
bool operator==(const this_type& x) const;
|
|
bool operator!=(const this_type& x) const;
|
|
|
|
bool test(size_type i) const;
|
|
bool any() const;
|
|
bool none() const;
|
|
|
|
this_type operator<<(size_type n) const;
|
|
this_type operator>>(size_type n) const;
|
|
|
|
// Finds the index of the first "on" bit, returns kSize if none are set.
|
|
size_type find_first() const;
|
|
|
|
// Finds the index of the next "on" bit after last_find, returns kSize if none are set.
|
|
size_type find_next(size_type last_find) const;
|
|
|
|
// Finds the index of the last "on" bit, returns kSize if none are set.
|
|
size_type find_last() const;
|
|
|
|
// Finds the index of the last "on" bit before last_find, returns kSize if none are set.
|
|
size_type find_prev(size_type last_find) const;
|
|
|
|
}; // bitset
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/// BitsetCountBits
|
|
///
|
|
/// This is a fast trick way to count bits without branches nor memory accesses.
|
|
///
|
|
#if(EA_PLATFORM_WORD_SIZE == 4)
|
|
inline uint32_t BitsetCountBits(uint32_t x)
|
|
{
|
|
x = x - ((x >> 1) & 0x55555555);
|
|
x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
|
|
x = (x + (x >> 4)) & 0x0F0F0F0F;
|
|
return (uint32_t)((x * 0x01010101) >> 24);
|
|
}
|
|
#else
|
|
inline uint32_t BitsetCountBits(uint64_t x)
|
|
{
|
|
// GCC 3.x's implementation of UINT64_C is broken and fails to deal with
|
|
// the code below correctly. So we make a workaround for it. Earlier and
|
|
// later versions of GCC don't have this bug.
|
|
#if defined(__GNUC__) && (__GNUC__ == 3)
|
|
x = x - ((x >> 1) & 0x5555555555555555ULL);
|
|
x = (x & 0x3333333333333333ULL) + ((x >> 2) & 0x3333333333333333ULL);
|
|
x = (x + (x >> 4)) & 0x0F0F0F0F0F0F0F0FULL;
|
|
return (uint32_t)((x * 0x0101010101010101ULL) >> 56);
|
|
#else
|
|
x = x - ((x >> 1) & UINT64_C(0x5555555555555555));
|
|
x = (x & UINT64_C(0x3333333333333333)) + ((x >> 2) & UINT64_C(0x3333333333333333));
|
|
x = (x + (x >> 4)) & UINT64_C(0x0F0F0F0F0F0F0F0F);
|
|
return (uint32_t)((x * UINT64_C(0x0101010101010101)) >> 56);
|
|
#endif
|
|
}
|
|
#endif
|
|
|
|
// const static char kBitsPerUint16[16] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4 };
|
|
#define EASTL_BITSET_COUNT_STRING "\0\1\1\2\1\2\2\3\1\2\2\3\2\3\3\4"
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// BitsetBase
|
|
//
|
|
// We tried two forms of array access here:
|
|
// for(word_type *pWord(mWord), *pWordEnd(mWord + NW); pWord < pWordEnd; ++pWord)
|
|
// *pWord = ...
|
|
// and
|
|
// for(size_t i = 0; i < NW; i++)
|
|
// mWord[i] = ...
|
|
//
|
|
// For our tests (~NW < 16), the latter (using []) access resulted in faster code.
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
template <size_t NW>
|
|
inline BitsetBase<NW>::BitsetBase()
|
|
{
|
|
reset();
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline BitsetBase<NW>::BitsetBase(uint32_t value)
|
|
{
|
|
// This implementation assumes that sizeof(value) <= sizeof(BitsetWordType).
|
|
EASTL_CT_ASSERT(sizeof(value) <= sizeof(BitsetWordType));
|
|
|
|
reset();
|
|
mWord[0] = static_cast<word_type>(value);
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline void BitsetBase<NW>::operator&=(const this_type& x)
|
|
{
|
|
for(size_t i = 0; i < NW; i++)
|
|
mWord[i] &= x.mWord[i];
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline void BitsetBase<NW>::operator|=(const this_type& x)
|
|
{
|
|
for(size_t i = 0; i < NW; i++)
|
|
mWord[i] |= x.mWord[i];
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline void BitsetBase<NW>::operator^=(const this_type& x)
|
|
{
|
|
for(size_t i = 0; i < NW; i++)
|
|
mWord[i] ^= x.mWord[i];
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline void BitsetBase<NW>::operator<<=(size_type n)
|
|
{
|
|
const size_type nWordShift = (size_type)(n >> kBitsPerWordShift);
|
|
|
|
if(nWordShift)
|
|
{
|
|
for(int i = (int)(NW - 1); i >= 0; --i)
|
|
mWord[i] = (nWordShift <= (size_type)i) ? mWord[i - nWordShift] : (word_type)0;
|
|
}
|
|
|
|
if(n &= kBitsPerWordMask)
|
|
{
|
|
for(size_t i = (NW - 1); i > 0; --i)
|
|
mWord[i] = (word_type)((mWord[i] << n) | (mWord[i - 1] >> (kBitsPerWord - n)));
|
|
mWord[0] <<= n;
|
|
}
|
|
|
|
// We let the parent class turn off any upper bits.
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline void BitsetBase<NW>::operator>>=(size_type n)
|
|
{
|
|
const size_type nWordShift = (size_type)(n >> kBitsPerWordShift);
|
|
|
|
if(nWordShift)
|
|
{
|
|
for(size_t i = 0; i < NW; ++i)
|
|
mWord[i] = ((nWordShift < (NW - i)) ? mWord[i + nWordShift] : (word_type)0);
|
|
}
|
|
|
|
if(n &= kBitsPerWordMask)
|
|
{
|
|
for(size_t i = 0; i < (NW - 1); ++i)
|
|
mWord[i] = (word_type)((mWord[i] >> n) | (mWord[i + 1] << (kBitsPerWord - n)));
|
|
mWord[NW - 1] >>= n;
|
|
}
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline void BitsetBase<NW>::flip()
|
|
{
|
|
for(size_t i = 0; i < NW; i++)
|
|
mWord[i] = ~mWord[i];
|
|
// We let the parent class turn off any upper bits.
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline void BitsetBase<NW>::set()
|
|
{
|
|
for(size_t i = 0; i < NW; i++)
|
|
mWord[i] = ~static_cast<word_type>(0);
|
|
// We let the parent class turn off any upper bits.
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline void BitsetBase<NW>::set(size_type i, bool value)
|
|
{
|
|
if(value)
|
|
mWord[i >> kBitsPerWordShift] |= (static_cast<word_type>(1) << (i & kBitsPerWordMask));
|
|
else
|
|
mWord[i >> kBitsPerWordShift] &= ~(static_cast<word_type>(1) << (i & kBitsPerWordMask));
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline void BitsetBase<NW>::reset()
|
|
{
|
|
if(NW > 16) // This is a constant expression and should be optimized away.
|
|
{
|
|
// This will be fastest if compiler intrinsic function optimizations are enabled.
|
|
memset(mWord, 0, sizeof(mWord));
|
|
}
|
|
else
|
|
{
|
|
for(size_t i = 0; i < NW; i++)
|
|
mWord[i] = 0;
|
|
}
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline bool BitsetBase<NW>::operator==(const this_type& x) const
|
|
{
|
|
for(size_t i = 0; i < NW; i++)
|
|
{
|
|
if(mWord[i] != x.mWord[i])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline bool BitsetBase<NW>::any() const
|
|
{
|
|
for(size_t i = 0; i < NW; i++)
|
|
{
|
|
if(mWord[i])
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline typename BitsetBase<NW>::size_type
|
|
BitsetBase<NW>::count() const
|
|
{
|
|
size_type n = 0;
|
|
|
|
for(size_t i = 0; i < NW; i++)
|
|
{
|
|
#if defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 304) && !defined(__SNC__) && !defined(EA_PLATFORM_ANDROID) // GCC 3.4 or later
|
|
#if(EA_PLATFORM_WORD_SIZE == 4)
|
|
n += (size_type)__builtin_popcountl(mWord[i]);
|
|
#else
|
|
n += (size_type)__builtin_popcountll(mWord[i]);
|
|
#endif
|
|
#elif defined(__GNUC__) && (__GNUC__ < 3)
|
|
n += BitsetCountBits(mWord[i]); // GCC 2.x compiler inexplicably blows up on the code below.
|
|
#else
|
|
for(word_type w = mWord[i]; w; w >>= 4)
|
|
n += EASTL_BITSET_COUNT_STRING[w & 0xF];
|
|
|
|
// Version which seems to run slower in benchmarks:
|
|
// n += BitsetCountBits(mWord[i]);
|
|
#endif
|
|
|
|
}
|
|
return n;
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline unsigned long BitsetBase<NW>::to_ulong() const
|
|
{
|
|
#if EASTL_EXCEPTIONS_ENABLED
|
|
for(size_t i = 1; i < NW; ++i)
|
|
{
|
|
if(mWord[i])
|
|
throw overflow_error("BitsetBase::to_ulong");
|
|
}
|
|
#endif
|
|
return (unsigned long)mWord[0]; // Todo: We need to deal with the case whereby sizeof(word_type) < sizeof(unsigned long)
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline typename BitsetBase<NW>::word_type&
|
|
BitsetBase<NW>::DoGetWord(size_type i)
|
|
{
|
|
return mWord[i >> kBitsPerWordShift];
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline typename BitsetBase<NW>::word_type
|
|
BitsetBase<NW>::DoGetWord(size_type i) const
|
|
{
|
|
return mWord[i >> kBitsPerWordShift];
|
|
}
|
|
|
|
|
|
#if(EA_PLATFORM_WORD_SIZE == 4)
|
|
inline uint32_t GetFirstBit(uint32_t x)
|
|
{
|
|
if(x)
|
|
{
|
|
uint32_t n = 1;
|
|
|
|
if((x & 0x0000FFFF) == 0) { n += 16; x >>= 16; }
|
|
if((x & 0x000000FF) == 0) { n += 8; x >>= 8; }
|
|
if((x & 0x0000000F) == 0) { n += 4; x >>= 4; }
|
|
if((x & 0x00000003) == 0) { n += 2; x >>= 2; }
|
|
|
|
return (n - ((uint32_t)x & 1));
|
|
}
|
|
|
|
return 32;
|
|
}
|
|
#else
|
|
inline uint32_t GetFirstBit(uint64_t x)
|
|
{
|
|
if(x)
|
|
{
|
|
uint32_t n = 1;
|
|
|
|
if((x & 0xFFFFFFFF) == 0) { n += 32; x >>= 32; }
|
|
if((x & 0x0000FFFF) == 0) { n += 16; x >>= 16; }
|
|
if((x & 0x000000FF) == 0) { n += 8; x >>= 8; }
|
|
if((x & 0x0000000F) == 0) { n += 4; x >>= 4; }
|
|
if((x & 0x00000003) == 0) { n += 2; x >>= 2; }
|
|
|
|
return (n - ((uint32_t)x & 1));
|
|
}
|
|
|
|
return 64;
|
|
}
|
|
#endif
|
|
|
|
|
|
template <size_t NW>
|
|
inline typename BitsetBase<NW>::size_type
|
|
BitsetBase<NW>::DoFindFirst() const
|
|
{
|
|
for(size_type word_index = 0; word_index < NW; ++word_index)
|
|
{
|
|
const size_type fbiw = GetFirstBit(mWord[word_index]);
|
|
|
|
if(fbiw != kBitsPerWord)
|
|
return (word_index * kBitsPerWord) + fbiw;
|
|
}
|
|
|
|
return (size_type)NW * kBitsPerWord;
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline typename BitsetBase<NW>::size_type
|
|
BitsetBase<NW>::DoFindNext(size_type last_find) const
|
|
{
|
|
// Start looking from the next bit.
|
|
++last_find;
|
|
|
|
// Set initial state based on last find.
|
|
size_type word_index = static_cast<size_type>(last_find >> kBitsPerWordShift);
|
|
size_type bit_index = static_cast<size_type>(last_find & kBitsPerWordMask);
|
|
|
|
// To do: There probably is a more elegant way to write looping below.
|
|
if(word_index < NW)
|
|
{
|
|
// Mask off previous bits of the word so our search becomes a "find first".
|
|
word_type this_word = mWord[word_index] & (~static_cast<word_type>(0) << bit_index);
|
|
|
|
for(;;)
|
|
{
|
|
const size_type fbiw = GetFirstBit(this_word);
|
|
|
|
if(fbiw != kBitsPerWord)
|
|
return (word_index * kBitsPerWord) + fbiw;
|
|
|
|
if(++word_index < NW)
|
|
this_word = mWord[word_index];
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
|
|
return (size_type)NW * kBitsPerWord;
|
|
}
|
|
|
|
|
|
#if(EA_PLATFORM_WORD_SIZE == 4)
|
|
inline uint32_t GetLastBit(uint32_t x)
|
|
{
|
|
if(x)
|
|
{
|
|
uint32_t n = 0;
|
|
|
|
if(x & 0xFFFF0000) { n += 16; x >>= 16; }
|
|
if(x & 0xFFFFFF00) { n += 8; x >>= 8; }
|
|
if(x & 0xFFFFFFF0) { n += 4; x >>= 4; }
|
|
if(x & 0xFFFFFFFC) { n += 2; x >>= 2; }
|
|
if(x & 0xFFFFFFFE) { n += 1; }
|
|
|
|
return n;
|
|
}
|
|
|
|
return 32;
|
|
}
|
|
#else
|
|
inline uint32_t GetLastBit(uint64_t x)
|
|
{
|
|
if(x)
|
|
{
|
|
uint32_t n = 0;
|
|
|
|
if(x & UINT64_C(0xFFFFFFFF00000000)) { n += 32; x >>= 32; }
|
|
if(x & 0xFFFF0000) { n += 16; x >>= 16; }
|
|
if(x & 0xFFFFFF00) { n += 8; x >>= 8; }
|
|
if(x & 0xFFFFFFF0) { n += 4; x >>= 4; }
|
|
if(x & 0xFFFFFFFC) { n += 2; x >>= 2; }
|
|
if(x & 0xFFFFFFFE) { n += 1; }
|
|
|
|
return n;
|
|
}
|
|
|
|
return 64;
|
|
}
|
|
#endif
|
|
|
|
template <size_t NW>
|
|
inline typename BitsetBase<NW>::size_type
|
|
BitsetBase<NW>::DoFindLast() const
|
|
{
|
|
for(size_t word_index = (size_type)NW - 1; word_index < NW; --word_index)
|
|
{
|
|
const size_type lbiw = GetLastBit(mWord[word_index]);
|
|
|
|
if(lbiw != kBitsPerWord)
|
|
return (word_index * kBitsPerWord) + lbiw;
|
|
}
|
|
|
|
return (size_type)NW * kBitsPerWord;
|
|
}
|
|
|
|
|
|
template <size_t NW>
|
|
inline typename BitsetBase<NW>::size_type
|
|
BitsetBase<NW>::DoFindPrev(size_type last_find) const
|
|
{
|
|
if(last_find > 0)
|
|
{
|
|
// Set initial state based on last find.
|
|
size_type word_index = static_cast<size_type>(last_find >> kBitsPerWordShift);
|
|
size_type bit_index = static_cast<size_type>(last_find & kBitsPerWordMask);
|
|
|
|
// Mask off subsequent bits of the word so our search becomes a "find last".
|
|
word_type mask = (~static_cast<word_type>(0) >> (kBitsPerWord - 1 - bit_index)) >> 1; // We do two shifts here because many CPUs ignore requests to shift 32 bit integers by 32 bits, which could be the case above.
|
|
word_type this_word = mWord[word_index] & mask;
|
|
|
|
for(;;)
|
|
{
|
|
const size_type lbiw = GetLastBit(this_word);
|
|
|
|
if(lbiw != kBitsPerWord)
|
|
return (word_index * kBitsPerWord) + lbiw;
|
|
|
|
if(word_index > 0)
|
|
this_word = mWord[--word_index];
|
|
else
|
|
break;
|
|
}
|
|
}
|
|
|
|
return (size_type)NW * kBitsPerWord;
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// BitsetBase<1>
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
inline BitsetBase<1>::BitsetBase()
|
|
{
|
|
mWord[0] = 0;
|
|
}
|
|
|
|
|
|
inline BitsetBase<1>::BitsetBase(uint32_t value)
|
|
{
|
|
// This implementation assumes that sizeof(value) <= sizeof(BitsetWordType).
|
|
EASTL_CT_ASSERT(sizeof(value) <= sizeof(BitsetWordType));
|
|
|
|
mWord[0] = static_cast<word_type>(value);
|
|
}
|
|
|
|
|
|
inline void BitsetBase<1>::operator&=(const this_type& x)
|
|
{
|
|
mWord[0] &= x.mWord[0];
|
|
}
|
|
|
|
|
|
inline void BitsetBase<1>::operator|=(const this_type& x)
|
|
{
|
|
mWord[0] |= x.mWord[0];
|
|
}
|
|
|
|
|
|
inline void BitsetBase<1>::operator^=(const this_type& x)
|
|
{
|
|
mWord[0] ^= x.mWord[0];
|
|
}
|
|
|
|
|
|
inline void BitsetBase<1>::operator<<=(size_type n)
|
|
{
|
|
mWord[0] <<= n;
|
|
// We let the parent class turn off any upper bits.
|
|
}
|
|
|
|
|
|
inline void BitsetBase<1>::operator>>=(size_type n)
|
|
{
|
|
mWord[0] >>= n;
|
|
}
|
|
|
|
|
|
inline void BitsetBase<1>::flip()
|
|
{
|
|
mWord[0] = ~mWord[0];
|
|
// We let the parent class turn off any upper bits.
|
|
}
|
|
|
|
|
|
inline void BitsetBase<1>::set()
|
|
{
|
|
mWord[0] = ~static_cast<word_type>(0);
|
|
// We let the parent class turn off any upper bits.
|
|
}
|
|
|
|
|
|
inline void BitsetBase<1>::set(size_type i, bool value)
|
|
{
|
|
if(value)
|
|
mWord[0] |= (static_cast<word_type>(1) << i);
|
|
else
|
|
mWord[0] &= ~(static_cast<word_type>(1) << i);
|
|
}
|
|
|
|
|
|
inline void BitsetBase<1>::reset()
|
|
{
|
|
mWord[0] = 0;
|
|
}
|
|
|
|
|
|
inline bool BitsetBase<1>::operator==(const this_type& x) const
|
|
{
|
|
return mWord[0] == x.mWord[0];
|
|
}
|
|
|
|
|
|
inline bool BitsetBase<1>::any() const
|
|
{
|
|
return mWord[0] != 0;
|
|
}
|
|
|
|
|
|
inline BitsetBase<1>::size_type
|
|
BitsetBase<1>::count() const
|
|
{
|
|
#if defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 304) && !defined(__SNC__) && !defined(EA_PLATFORM_ANDROID) // GCC 3.4 or later
|
|
#if(EA_PLATFORM_WORD_SIZE == 4)
|
|
return (size_type)__builtin_popcountl(mWord[0]);
|
|
#else
|
|
return (size_type)__builtin_popcountll(mWord[0]);
|
|
#endif
|
|
#elif defined(__GNUC__) && (__GNUC__ < 3)
|
|
return BitsetCountBits(mWord[0]); // GCC 2.x compiler inexplicably blows up on the code below.
|
|
#else
|
|
size_type n = 0;
|
|
for(word_type w = mWord[0]; w; w >>= 4)
|
|
n += EASTL_BITSET_COUNT_STRING[w & 0xF];
|
|
return n;
|
|
#endif
|
|
}
|
|
|
|
|
|
inline unsigned long BitsetBase<1>::to_ulong() const
|
|
{
|
|
return static_cast<unsigned long>(mWord[0]);
|
|
}
|
|
|
|
|
|
inline BitsetBase<1>::word_type&
|
|
BitsetBase<1>::DoGetWord(size_type)
|
|
{
|
|
return mWord[0];
|
|
}
|
|
|
|
|
|
inline BitsetBase<1>::word_type
|
|
BitsetBase<1>::DoGetWord(size_type) const
|
|
{
|
|
return mWord[0];
|
|
}
|
|
|
|
|
|
inline BitsetBase<1>::size_type
|
|
BitsetBase<1>::DoFindFirst() const
|
|
{
|
|
return GetFirstBit(mWord[0]);
|
|
}
|
|
|
|
|
|
inline BitsetBase<1>::size_type
|
|
BitsetBase<1>::DoFindNext(size_type last_find) const
|
|
{
|
|
if(++last_find < kBitsPerWord)
|
|
{
|
|
// Mask off previous bits of word so our search becomes a "find first".
|
|
const word_type this_word = mWord[0] & ((~static_cast<word_type>(0)) << last_find);
|
|
|
|
return GetFirstBit(this_word);
|
|
}
|
|
|
|
return kBitsPerWord;
|
|
}
|
|
|
|
|
|
inline BitsetBase<1>::size_type
|
|
BitsetBase<1>::DoFindLast() const
|
|
{
|
|
return GetLastBit(mWord[0]);
|
|
}
|
|
|
|
|
|
inline BitsetBase<1>::size_type
|
|
BitsetBase<1>::DoFindPrev(size_type last_find) const
|
|
{
|
|
if(last_find > 0)
|
|
{
|
|
// Mask off previous bits of word so our search becomes a "find first".
|
|
const word_type this_word = mWord[0] & ((~static_cast<word_type>(0)) >> (kBitsPerWord - last_find));
|
|
|
|
return GetLastBit(this_word);
|
|
}
|
|
|
|
return kBitsPerWord;
|
|
}
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// BitsetBase<2>
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
inline BitsetBase<2>::BitsetBase()
|
|
{
|
|
mWord[0] = 0;
|
|
mWord[1] = 0;
|
|
}
|
|
|
|
|
|
inline BitsetBase<2>::BitsetBase(uint32_t value)
|
|
{
|
|
// This implementation assumes that sizeof(value) <= sizeof(BitsetWordType).
|
|
EASTL_CT_ASSERT(sizeof(value) <= sizeof(BitsetWordType));
|
|
|
|
mWord[0] = static_cast<word_type>(value);
|
|
mWord[1] = 0;
|
|
}
|
|
|
|
|
|
inline void BitsetBase<2>::operator&=(const this_type& x)
|
|
{
|
|
mWord[0] &= x.mWord[0];
|
|
mWord[1] &= x.mWord[1];
|
|
}
|
|
|
|
|
|
inline void BitsetBase<2>::operator|=(const this_type& x)
|
|
{
|
|
mWord[0] |= x.mWord[0];
|
|
mWord[1] |= x.mWord[1];
|
|
}
|
|
|
|
|
|
inline void BitsetBase<2>::operator^=(const this_type& x)
|
|
{
|
|
mWord[0] ^= x.mWord[0];
|
|
mWord[1] ^= x.mWord[1];
|
|
}
|
|
|
|
|
|
inline void BitsetBase<2>::operator<<=(size_type n)
|
|
{
|
|
if(EASTL_UNLIKELY(n >= kBitsPerWord)) // parent expected to handle high bits and n >= 64
|
|
{
|
|
mWord[1] = mWord[0];
|
|
mWord[0] = 0;
|
|
n -= kBitsPerWord;
|
|
}
|
|
|
|
mWord[1] = (mWord[1] << n) | (mWord[0] >> (kBitsPerWord - n)); // Intentionally use | instead of +.
|
|
mWord[0] <<= n;
|
|
// We let the parent class turn off any upper bits.
|
|
}
|
|
|
|
|
|
inline void BitsetBase<2>::operator>>=(size_type n)
|
|
{
|
|
if(EASTL_UNLIKELY(n >= kBitsPerWord)) // parent expected to handle n >= 64
|
|
{
|
|
mWord[0] = mWord[1];
|
|
mWord[1] = 0;
|
|
n -= kBitsPerWord;
|
|
}
|
|
|
|
mWord[0] = (mWord[0] >> n) | (mWord[1] << (kBitsPerWord - n)); // Intentionally use | instead of +.
|
|
mWord[1] >>= n;
|
|
}
|
|
|
|
|
|
inline void BitsetBase<2>::flip()
|
|
{
|
|
mWord[0] = ~mWord[0];
|
|
mWord[1] = ~mWord[1];
|
|
// We let the parent class turn off any upper bits.
|
|
}
|
|
|
|
|
|
inline void BitsetBase<2>::set()
|
|
{
|
|
mWord[0] = ~static_cast<word_type>(0);
|
|
mWord[1] = ~static_cast<word_type>(0);
|
|
// We let the parent class turn off any upper bits.
|
|
}
|
|
|
|
|
|
inline void BitsetBase<2>::set(size_type i, bool value)
|
|
{
|
|
if(value)
|
|
mWord[i >> kBitsPerWordShift] |= (static_cast<word_type>(1) << (i & kBitsPerWordMask));
|
|
else
|
|
mWord[i >> kBitsPerWordShift] &= ~(static_cast<word_type>(1) << (i & kBitsPerWordMask));
|
|
}
|
|
|
|
|
|
inline void BitsetBase<2>::reset()
|
|
{
|
|
mWord[0] = 0;
|
|
mWord[1] = 0;
|
|
}
|
|
|
|
|
|
inline bool BitsetBase<2>::operator==(const this_type& x) const
|
|
{
|
|
return (mWord[0] == x.mWord[0]) && (mWord[1] == x.mWord[1]);
|
|
}
|
|
|
|
|
|
inline bool BitsetBase<2>::any() const
|
|
{
|
|
// Or with two branches: { return (mWord[0] != 0) || (mWord[1] != 0); }
|
|
return (mWord[0] | mWord[1]) != 0;
|
|
}
|
|
|
|
|
|
inline BitsetBase<2>::size_type
|
|
BitsetBase<2>::count() const
|
|
{
|
|
#if defined(__GNUC__) && (((__GNUC__ * 100) + __GNUC_MINOR__) >= 304) && !defined(__SNC__) && !defined(EA_PLATFORM_ANDROID) // GCC 3.4 or later
|
|
#if(EA_PLATFORM_WORD_SIZE == 4)
|
|
return (size_type)__builtin_popcountl(mWord[0]) + (size_type)__builtin_popcountl(mWord[1]);
|
|
#else
|
|
return (size_type)__builtin_popcountll(mWord[0]) + (size_type)__builtin_popcountll(mWord[1]);
|
|
#endif
|
|
|
|
#else
|
|
return BitsetCountBits(mWord[0]) + BitsetCountBits(mWord[1]);
|
|
#endif
|
|
}
|
|
|
|
|
|
inline unsigned long BitsetBase<2>::to_ulong() const
|
|
{
|
|
#if EASTL_EXCEPTIONS_ENABLED
|
|
if(mWord[1])
|
|
throw overflow_error("BitsetBase::to_ulong");
|
|
#endif
|
|
return (unsigned long)mWord[0]; // Todo: We need to deal with the case whereby sizeof(word_type) < sizeof(unsigned long)
|
|
}
|
|
|
|
|
|
inline BitsetBase<2>::word_type&
|
|
BitsetBase<2>::DoGetWord(size_type i)
|
|
{
|
|
return mWord[i >> kBitsPerWordShift];
|
|
}
|
|
|
|
|
|
inline BitsetBase<2>::word_type
|
|
BitsetBase<2>::DoGetWord(size_type i) const
|
|
{
|
|
return mWord[i >> kBitsPerWordShift];
|
|
}
|
|
|
|
|
|
inline BitsetBase<2>::size_type
|
|
BitsetBase<2>::DoFindFirst() const
|
|
{
|
|
size_type fbiw = GetFirstBit(mWord[0]);
|
|
|
|
if(fbiw != kBitsPerWord)
|
|
return fbiw;
|
|
|
|
fbiw = GetFirstBit(mWord[1]);
|
|
|
|
if(fbiw != kBitsPerWord)
|
|
return kBitsPerWord + fbiw;
|
|
|
|
return 2 * kBitsPerWord;
|
|
}
|
|
|
|
|
|
inline BitsetBase<2>::size_type
|
|
BitsetBase<2>::DoFindNext(size_type last_find) const
|
|
{
|
|
// If the last find was in the first word, we must check it and then possibly the second.
|
|
if(++last_find < (size_type)kBitsPerWord)
|
|
{
|
|
// Mask off previous bits of word so our search becomes a "find first".
|
|
word_type this_word = mWord[0] & ((~static_cast<word_type>(0)) << last_find);
|
|
|
|
// Step through words.
|
|
size_type fbiw = GetFirstBit(this_word);
|
|
|
|
if(fbiw != kBitsPerWord)
|
|
return fbiw;
|
|
|
|
fbiw = GetFirstBit(mWord[1]);
|
|
|
|
if(fbiw != kBitsPerWord)
|
|
return kBitsPerWord + fbiw;
|
|
}
|
|
else if(last_find < (size_type)(2 * kBitsPerWord))
|
|
{
|
|
// The last find was in the second word, remove the bit count of the first word from the find.
|
|
last_find -= kBitsPerWord;
|
|
|
|
// Mask off previous bits of word so our search becomes a "find first".
|
|
word_type this_word = mWord[1] & ((~static_cast<word_type>(0)) << last_find);
|
|
|
|
const size_type fbiw = GetFirstBit(this_word);
|
|
|
|
if(fbiw != kBitsPerWord)
|
|
return kBitsPerWord + fbiw;
|
|
}
|
|
|
|
return 2 * kBitsPerWord;
|
|
}
|
|
|
|
|
|
inline BitsetBase<2>::size_type
|
|
BitsetBase<2>::DoFindLast() const
|
|
{
|
|
size_type lbiw = GetLastBit(mWord[1]);
|
|
|
|
if(lbiw != kBitsPerWord)
|
|
return kBitsPerWord + lbiw;
|
|
|
|
lbiw = GetLastBit(mWord[0]);
|
|
|
|
if(lbiw != kBitsPerWord)
|
|
return lbiw;
|
|
|
|
return 2 * kBitsPerWord;
|
|
}
|
|
|
|
|
|
inline BitsetBase<2>::size_type
|
|
BitsetBase<2>::DoFindPrev(size_type last_find) const
|
|
{
|
|
// If the last find was in the second word, we must check it and then possibly the first.
|
|
if(last_find > (size_type)kBitsPerWord)
|
|
{
|
|
// This has the same effect as last_find %= kBitsPerWord in our case.
|
|
last_find -= kBitsPerWord;
|
|
|
|
// Mask off previous bits of word so our search becomes a "find first".
|
|
word_type this_word = mWord[1] & ((~static_cast<word_type>(0)) >> (kBitsPerWord - last_find));
|
|
|
|
// Step through words.
|
|
size_type lbiw = GetLastBit(this_word);
|
|
|
|
if(lbiw != kBitsPerWord)
|
|
return kBitsPerWord + lbiw;
|
|
|
|
lbiw = GetLastBit(mWord[0]);
|
|
|
|
if(lbiw != kBitsPerWord)
|
|
return lbiw;
|
|
}
|
|
else if(last_find != 0)
|
|
{
|
|
// Mask off previous bits of word so our search becomes a "find first".
|
|
word_type this_word = mWord[0] & ((~static_cast<word_type>(0)) >> (kBitsPerWord - last_find));
|
|
|
|
const size_type lbiw = GetLastBit(this_word);
|
|
|
|
if(lbiw != kBitsPerWord)
|
|
return lbiw;
|
|
}
|
|
|
|
return 2 * kBitsPerWord;
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// bitset::reference
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
template <size_t N>
|
|
inline bitset<N>::reference::reference(const bitset& x, size_type i)
|
|
: mpBitWord(&const_cast<bitset&>(x).DoGetWord(i)),
|
|
mnBitIndex(i & kBitsPerWordMask)
|
|
{ // We have an issue here because the above is casting away the const-ness of the source bitset.
|
|
// Empty
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::reference&
|
|
bitset<N>::reference::operator=(bool value)
|
|
{
|
|
if(value)
|
|
*mpBitWord |= (static_cast<word_type>(1) << (mnBitIndex & kBitsPerWordMask));
|
|
else
|
|
*mpBitWord &= ~(static_cast<word_type>(1) << (mnBitIndex & kBitsPerWordMask));
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::reference&
|
|
bitset<N>::reference::operator=(const reference& x)
|
|
{
|
|
if(*x.mpBitWord & (static_cast<word_type>(1) << (x.mnBitIndex & kBitsPerWordMask)))
|
|
*mpBitWord |= (static_cast<word_type>(1) << (mnBitIndex & kBitsPerWordMask));
|
|
else
|
|
*mpBitWord &= ~(static_cast<word_type>(1) << (mnBitIndex & kBitsPerWordMask));
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline bool bitset<N>::reference::operator~() const
|
|
{
|
|
return (*mpBitWord & (static_cast<word_type>(1) << (mnBitIndex & kBitsPerWordMask))) == 0;
|
|
}
|
|
|
|
|
|
//Defined inline in the class because Metrowerks fails to be able to compile it here.
|
|
//template <size_t N>
|
|
//inline bitset<N>::reference::operator bool() const
|
|
//{
|
|
// return (*mpBitWord & (static_cast<word_type>(1) << (mnBitIndex & kBitsPerWordMask))) != 0;
|
|
//}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::reference&
|
|
bitset<N>::reference::flip()
|
|
{
|
|
*mpBitWord ^= static_cast<word_type>(1) << (mnBitIndex & kBitsPerWordMask);
|
|
return *this;
|
|
}
|
|
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// bitset
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
template <size_t N>
|
|
inline bitset<N>::bitset()
|
|
: base_type()
|
|
{
|
|
// Empty. The base class will set all bits to zero.
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline bitset<N>::bitset(uint32_t value)
|
|
: base_type(value)
|
|
{
|
|
if((N & kBitsPerWordMask) || (N == 0)) // If there are any high bits to clear... (If we didn't have this check, then the code below would do the wrong thing when N == 32.
|
|
mWord[kNW - 1] &= ~(~static_cast<word_type>(0) << (N & kBitsPerWordMask)); // This clears any high unused bits.
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type&
|
|
bitset<N>::operator&=(const this_type& x)
|
|
{
|
|
base_type::operator&=(x);
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type&
|
|
bitset<N>::operator|=(const this_type& x)
|
|
{
|
|
base_type::operator|=(x);
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type&
|
|
bitset<N>::operator^=(const this_type& x)
|
|
{
|
|
base_type::operator^=(x);
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type&
|
|
bitset<N>::operator<<=(size_type n)
|
|
{
|
|
if(EASTL_LIKELY((intptr_t)n < (intptr_t)N))
|
|
{
|
|
base_type::operator<<=(n);
|
|
if((N & kBitsPerWordMask) || (N == 0)) // If there are any high bits to clear... (If we didn't have this check, then the code below would do the wrong thing when N == 32.
|
|
mWord[kNW - 1] &= ~(~static_cast<word_type>(0) << (N & kBitsPerWordMask)); // This clears any high unused bits. We need to do this so that shift operations proceed correctly.
|
|
}
|
|
else
|
|
base_type::reset();
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type&
|
|
bitset<N>::operator>>=(size_type n)
|
|
{
|
|
if(EASTL_LIKELY(n < N))
|
|
base_type::operator>>=(n);
|
|
else
|
|
base_type::reset();
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type&
|
|
bitset<N>::set()
|
|
{
|
|
base_type::set(); // This sets all bits.
|
|
if((N & kBitsPerWordMask) || (N == 0)) // If there are any high bits to clear... (If we didn't have this check, then the code below would do the wrong thing when N == 32.
|
|
mWord[kNW - 1] &= ~(~static_cast<word_type>(0) << (N & kBitsPerWordMask)); // This clears any high unused bits. We need to do this so that shift operations proceed correctly.
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type&
|
|
bitset<N>::set(size_type i, bool value)
|
|
{
|
|
if(i < N)
|
|
base_type::set(i, value);
|
|
|
|
#if EASTL_ASSERT_ENABLED
|
|
if(EASTL_UNLIKELY(!(i < N)))
|
|
EASTL_FAIL_MSG("bitset::set -- out of range");
|
|
#endif
|
|
|
|
#if EASTL_EXCEPTIONS_ENABLED
|
|
else
|
|
throw out_of_range("bitset::set");
|
|
#endif
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type&
|
|
bitset<N>::reset()
|
|
{
|
|
base_type::reset();
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type&
|
|
bitset<N>::reset(size_type i)
|
|
{
|
|
if(EASTL_LIKELY(i < N))
|
|
DoGetWord(i) &= ~(static_cast<word_type>(1) << (i & kBitsPerWordMask));
|
|
|
|
#if EASTL_ASSERT_ENABLED
|
|
if(EASTL_UNLIKELY(!(i < N)))
|
|
EASTL_FAIL_MSG("bitset::reset -- out of range");
|
|
#endif
|
|
|
|
#if EASTL_EXCEPTIONS_ENABLED
|
|
else
|
|
throw out_of_range("bitset::reset");
|
|
#endif
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type&
|
|
bitset<N>::flip()
|
|
{
|
|
base_type::flip();
|
|
if((N & kBitsPerWordMask) || (N == 0)) // If there are any high bits to clear... (If we didn't have this check, then the code below would do the wrong thing when N == 32.
|
|
mWord[kNW - 1] &= ~(~static_cast<word_type>(0) << (N & kBitsPerWordMask)); // This clears any high unused bits. We need to do this so that shift operations proceed correctly.
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type&
|
|
bitset<N>::flip(size_type i)
|
|
{
|
|
if(EASTL_LIKELY(i < N))
|
|
DoGetWord(i) ^= (static_cast<word_type>(1) << (i & kBitsPerWordMask));
|
|
|
|
#if EASTL_ASSERT_ENABLED
|
|
if(EASTL_UNLIKELY(!(i < N)))
|
|
EASTL_FAIL_MSG("bitset::flip -- out of range");
|
|
#endif
|
|
|
|
#if EASTL_EXCEPTIONS_ENABLED
|
|
else
|
|
throw out_of_range("bitset::flip");
|
|
#endif
|
|
return *this;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type
|
|
bitset<N>::operator~() const
|
|
{
|
|
return this_type(*this).flip();
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::reference
|
|
bitset<N>::operator[](size_type i)
|
|
{
|
|
#if EASTL_ASSERT_ENABLED
|
|
if(EASTL_UNLIKELY(!(i < N)))
|
|
EASTL_FAIL_MSG("bitset::operator[] -- out of range");
|
|
#endif
|
|
|
|
return reference(*this, i);
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline bool bitset<N>::operator[](size_type i) const
|
|
{
|
|
#if EASTL_ASSERT_ENABLED
|
|
if(EASTL_UNLIKELY(!(i < N)))
|
|
EASTL_FAIL_MSG("bitset::operator[] -- out of range");
|
|
#endif
|
|
|
|
return (DoGetWord(i) & (static_cast<word_type>(1) << (i & kBitsPerWordMask))) != 0;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline const typename bitset<N>::word_type* bitset<N>::data() const
|
|
{
|
|
return base_type::mWord;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::word_type* bitset<N>::data()
|
|
{
|
|
return base_type::mWord;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline unsigned long bitset<N>::to_ulong() const
|
|
{
|
|
return base_type::to_ulong();
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::size_type
|
|
bitset<N>::count() const
|
|
{
|
|
return base_type::count();
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::size_type
|
|
bitset<N>::size() const
|
|
{
|
|
return (size_type)N;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline bool bitset<N>::operator==(const this_type& x) const
|
|
{
|
|
return base_type::operator==(x);
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline bool bitset<N>::operator!=(const this_type& x) const
|
|
{
|
|
return !base_type::operator==(x);
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline bool bitset<N>::test(size_type i) const
|
|
{
|
|
if(EASTL_LIKELY(i < N))
|
|
return (DoGetWord(i) & (static_cast<word_type>(1) << (i & kBitsPerWordMask))) != 0;
|
|
|
|
#if EASTL_ASSERT_ENABLED
|
|
if(EASTL_UNLIKELY(!(i < N)))
|
|
EASTL_FAIL_MSG("bitset::test -- out of range");
|
|
#endif
|
|
|
|
#if EASTL_EXCEPTIONS_ENABLED
|
|
else
|
|
throw out_of_range("bitset::test");
|
|
#endif
|
|
return false;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline bool bitset<N>::any() const
|
|
{
|
|
return base_type::any();
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline bool bitset<N>::none() const
|
|
{
|
|
return !base_type::any();
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type
|
|
bitset<N>::operator<<(size_type n) const
|
|
{
|
|
return this_type(*this).operator<<=(n);
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::this_type
|
|
bitset<N>::operator>>(size_type n) const
|
|
{
|
|
return this_type(*this).operator>>=(n);
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::size_type
|
|
bitset<N>::find_first() const
|
|
{
|
|
const size_type i = base_type::DoFindFirst();
|
|
|
|
if(i < (kNW * kBitsPerWord)) // This multiplication is a compile-time constant.
|
|
return i;
|
|
|
|
return kSize;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::size_type
|
|
bitset<N>::find_next(size_type last_find) const
|
|
{
|
|
const size_type i = base_type::DoFindNext(last_find);
|
|
|
|
if(i < (kNW * kBitsPerWord))// This multiplication is a compile-time constant.
|
|
return i;
|
|
|
|
return kSize;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::size_type
|
|
bitset<N>::find_last() const
|
|
{
|
|
const size_type i = base_type::DoFindLast();
|
|
|
|
if(i < (kNW * kBitsPerWord)) // This multiplication is a compile-time constant.
|
|
return i;
|
|
|
|
return kSize;
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline typename bitset<N>::size_type
|
|
bitset<N>::find_prev(size_type last_find) const
|
|
{
|
|
const size_type i = base_type::DoFindPrev(last_find);
|
|
|
|
if(i < (kNW * kBitsPerWord))// This multiplication is a compile-time constant.
|
|
return i;
|
|
|
|
return kSize;
|
|
}
|
|
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// global operators
|
|
///////////////////////////////////////////////////////////////////////////
|
|
|
|
template <size_t N>
|
|
inline bitset<N> operator&(const bitset<N>& a, const bitset<N>& b)
|
|
{
|
|
// We get betting inlining when we don't declare temporary variables.
|
|
return bitset<N>(a).operator&=(b);
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline bitset<N> operator|(const bitset<N>& a, const bitset<N>& b)
|
|
{
|
|
return bitset<N>(a).operator|=(b);
|
|
}
|
|
|
|
|
|
template <size_t N>
|
|
inline bitset<N> operator^(const bitset<N>& a, const bitset<N>& b)
|
|
{
|
|
return bitset<N>(a).operator^=(b);
|
|
}
|
|
|
|
|
|
} // namespace eastl
|
|
|
|
|
|
#if defined(_MSC_VER)
|
|
#pragma warning(pop)
|
|
#elif defined(__SNC__)
|
|
#pragma control %pop diag
|
|
#endif
|
|
|
|
|
|
#endif // Header include guard
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|