439 lines
9.2 KiB
Text
439 lines
9.2 KiB
Text
/**
|
|
* PANDA 3D SOFTWARE
|
|
* Copyright (c) Carnegie Mellon University. All rights reserved.
|
|
*
|
|
* All use of this software is subject to the terms of the revised BSD
|
|
* license. You should have received a copy of this license along
|
|
* with this source code in a file named "LICENSE."
|
|
*
|
|
* @file sparseArray.I
|
|
* @author drose
|
|
* @date 2007-02-14
|
|
*/
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE SparseArray::
|
|
SparseArray() : _inverse(false) {
|
|
}
|
|
|
|
/**
|
|
* Returns a SparseArray with an infinite array of bits, all on.
|
|
*/
|
|
INLINE SparseArray SparseArray::
|
|
all_on() {
|
|
SparseArray result;
|
|
result._inverse = true;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns a SparseArray whose bits are all off.
|
|
*/
|
|
INLINE SparseArray SparseArray::
|
|
all_off() {
|
|
return SparseArray();
|
|
}
|
|
|
|
/**
|
|
* Returns a SparseArray whose lower on_bits bits are on.
|
|
*/
|
|
INLINE SparseArray SparseArray::
|
|
lower_on(int on_bits) {
|
|
SparseArray result;
|
|
if (on_bits > 0) {
|
|
result._subranges.push_back(Subrange(0, on_bits));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns a SparseArray with only the indicated bit on.
|
|
*/
|
|
INLINE SparseArray SparseArray::
|
|
bit(int index) {
|
|
SparseArray result;
|
|
result.set_bit(index);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns a SparseArray whose size bits, beginning at low_bit, are on.
|
|
*/
|
|
INLINE SparseArray SparseArray::
|
|
range(int low_bit, int size) {
|
|
SparseArray result;
|
|
result.set_range(low_bit, size);
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* Returns true if there is a maximum number of bits that may be stored in
|
|
* this structure, false otherwise. If this returns true, the number may be
|
|
* queried in get_max_num_bits().
|
|
*
|
|
* This method always returns false. The SparseArray has no maximum number of
|
|
* bits. This method is defined so generic programming algorithms can use
|
|
* BitMask or SparseArray interchangeably.
|
|
*/
|
|
INLINE bool SparseArray::
|
|
has_max_num_bits() {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* If get_max_num_bits() returned true, this method may be called to return
|
|
* the maximum number of bits that may be stored in this structure. It is an
|
|
* error to call this if get_max_num_bits() return false.
|
|
*
|
|
* It is always an error to call this method. The SparseArray has no maximum
|
|
* number of bits. This method is defined so generic programming algorithms
|
|
* can use BitMask or SparseArray interchangeably.
|
|
*/
|
|
INLINE int SparseArray::
|
|
get_max_num_bits() {
|
|
nassert_raise("SparseArray has no maximum bit count");
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* Returns the current number of possibly different bits in this array. There
|
|
* are actually an infinite number of bits, but every bit higher than this bit
|
|
* will have the same value, either 0 or 1 (see get_highest_bits()).
|
|
*
|
|
* This number may grow and/or shrink automatically as needed.
|
|
*/
|
|
INLINE int SparseArray::
|
|
get_num_bits() const {
|
|
if (_subranges.empty()) {
|
|
return 0;
|
|
} else {
|
|
Subranges::const_iterator si = _subranges.begin() + _subranges.size() - 1;
|
|
return (*si)._end;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the nth bit is set, false if it is cleared. It is valid
|
|
* for n to increase beyond get_num_bits(), but the return value
|
|
* get_num_bits() will always be the same.
|
|
*/
|
|
INLINE bool SparseArray::
|
|
get_bit(int index) const {
|
|
return has_any_of(index, 1);
|
|
}
|
|
|
|
/**
|
|
* Sets the nth bit on. If n >= get_num_bits(), this automatically extends
|
|
* the array.
|
|
*/
|
|
INLINE void SparseArray::
|
|
set_bit(int index) {
|
|
set_range(index, 1);
|
|
}
|
|
|
|
/**
|
|
* Sets the nth bit off. If n >= get_num_bits(), this automatically extends
|
|
* the array.
|
|
*/
|
|
INLINE void SparseArray::
|
|
clear_bit(int index) {
|
|
clear_range(index, 1);
|
|
}
|
|
|
|
/**
|
|
* Sets the nth bit either on or off, according to the indicated bool value.
|
|
*/
|
|
INLINE void SparseArray::
|
|
set_bit_to(int index, bool value) {
|
|
if (value) {
|
|
set_bit(index);
|
|
} else {
|
|
clear_bit(index);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the infinite set of bits beyond get_num_bits() are all on,
|
|
* or false of they are all off.
|
|
*/
|
|
INLINE bool SparseArray::
|
|
get_highest_bits() const {
|
|
return _inverse;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the entire bitmask is zero, false otherwise.
|
|
*/
|
|
INLINE bool SparseArray::
|
|
is_zero() const {
|
|
if (_inverse) {
|
|
return false;
|
|
} else {
|
|
return _subranges.empty();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if the entire bitmask is one, false otherwise.
|
|
*/
|
|
bool SparseArray::
|
|
is_all_on() const {
|
|
if (_inverse) {
|
|
return _subranges.empty();
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if any bit in the indicated range is set, false otherwise.
|
|
*/
|
|
INLINE bool SparseArray::
|
|
has_any_of(int low_bit, int size) const {
|
|
if (_inverse) {
|
|
return !do_has_all(low_bit, low_bit + size);
|
|
} else {
|
|
return do_has_any(low_bit, low_bit + size);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if all bits in the indicated range are set, false otherwise.
|
|
*/
|
|
INLINE bool SparseArray::
|
|
has_all_of(int low_bit, int size) const {
|
|
if (_inverse) {
|
|
return !do_has_any(low_bit, low_bit + size);
|
|
} else {
|
|
return do_has_all(low_bit, low_bit + size);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the indicated range of bits on.
|
|
*/
|
|
INLINE void SparseArray::
|
|
set_range(int low_bit, int size) {
|
|
if (_inverse) {
|
|
return do_remove_range(low_bit, low_bit + size);
|
|
} else {
|
|
return do_add_range(low_bit, low_bit + size);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the indicated range of bits off.
|
|
*/
|
|
INLINE void SparseArray::
|
|
clear_range(int low_bit, int size) {
|
|
if (_inverse) {
|
|
return do_add_range(low_bit, low_bit + size);
|
|
} else {
|
|
return do_remove_range(low_bit, low_bit + size);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Sets the indicated range of bits to either on or off.
|
|
*/
|
|
INLINE void SparseArray::
|
|
set_range_to(bool value, int low_bit, int size) {
|
|
if (value) {
|
|
set_range(low_bit, size);
|
|
} else {
|
|
clear_range(low_bit, size);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Inverts all the bits in the SparseArray. This is equivalent to array =
|
|
* ~array.
|
|
*/
|
|
void SparseArray::
|
|
invert_in_place() {
|
|
_inverse = !_inverse;
|
|
}
|
|
|
|
/**
|
|
* Sets all the bits in the SparseArray off.
|
|
*/
|
|
void SparseArray::
|
|
clear() {
|
|
_subranges.clear();
|
|
_inverse = false;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE bool SparseArray::
|
|
operator == (const SparseArray &other) const {
|
|
return compare_to(other) == 0;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE bool SparseArray::
|
|
operator != (const SparseArray &other) const {
|
|
return compare_to(other) != 0;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the unsigned integer which is represented by this
|
|
* SparseArray is less than that of the other one, false otherwise.
|
|
*/
|
|
INLINE bool SparseArray::
|
|
operator < (const SparseArray &other) const {
|
|
return compare_to(other) < 0;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE SparseArray SparseArray::
|
|
operator & (const SparseArray &other) const {
|
|
SparseArray result(*this);
|
|
result &= other;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE SparseArray SparseArray::
|
|
operator | (const SparseArray &other) const {
|
|
SparseArray result(*this);
|
|
result |= other;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE SparseArray SparseArray::
|
|
operator ^ (const SparseArray &other) const {
|
|
SparseArray result(*this);
|
|
result ^= other;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE SparseArray SparseArray::
|
|
operator ~ () const {
|
|
SparseArray result(*this);
|
|
result.invert_in_place();
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE SparseArray SparseArray::
|
|
operator << (int shift) const {
|
|
SparseArray result(*this);
|
|
result <<= shift;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE SparseArray SparseArray::
|
|
operator >> (int shift) const {
|
|
SparseArray result(*this);
|
|
result >>= shift;
|
|
return result;
|
|
}
|
|
|
|
|
|
/**
|
|
* Logical left shift. Since negative bit positions have meaning in a
|
|
* SparseArray, real bit values are rotated in on the left (not necessarily
|
|
* zero).
|
|
*/
|
|
void SparseArray::
|
|
operator <<= (int shift) {
|
|
do_shift(shift);
|
|
}
|
|
|
|
/**
|
|
* Logical right shift. The rightmost bits become negative, but are not lost;
|
|
* they will reappear into the zero position if the array is later left-
|
|
* shifted.
|
|
*/
|
|
void SparseArray::
|
|
operator >>= (int shift) {
|
|
do_shift(-shift);
|
|
}
|
|
|
|
/**
|
|
* If this is true, the SparseArray is actually defined as a list of subranges
|
|
* of integers that are *not* in the set. If this is false (the default),
|
|
* then the subranges define the integers that *are* in the set. This affects
|
|
* the interpretation of the values returned by iterating through
|
|
* get_num_subranges().
|
|
*/
|
|
INLINE bool SparseArray::
|
|
is_inverse() const {
|
|
return _inverse;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of separate subranges stored in the SparseArray. You
|
|
* can use this limit to iterate through the subranges, calling
|
|
* get_subrange_begin() and get_subrange_end() for each one.
|
|
*
|
|
* Also see is_inverse().
|
|
*/
|
|
INLINE size_t SparseArray::
|
|
get_num_subranges() const {
|
|
return _subranges.size();
|
|
}
|
|
|
|
/**
|
|
* Returns the first numeric element in the nth subrange.
|
|
*
|
|
* Also see is_inverse().
|
|
*/
|
|
INLINE int SparseArray::
|
|
get_subrange_begin(size_t n) const {
|
|
nassertr(n < _subranges.size(), 0);
|
|
return _subranges[n]._begin;
|
|
}
|
|
|
|
/**
|
|
* Returns the last numeric element, plus one, in the nth subrange.
|
|
*
|
|
* Also see is_inverse().
|
|
*/
|
|
INLINE int SparseArray::
|
|
get_subrange_end(size_t n) const {
|
|
nassertr(n < _subranges.size(), 0);
|
|
return _subranges[n]._end;
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE SparseArray::Subrange::
|
|
Subrange(int begin, int end) :
|
|
_begin(begin),
|
|
_end(end)
|
|
{
|
|
}
|
|
|
|
/**
|
|
*
|
|
*/
|
|
INLINE bool SparseArray::Subrange::
|
|
operator < (const SparseArray::Subrange &other) const {
|
|
// We compare the end values, rather than the begin values, to make
|
|
// lower_bound() sensibly return a possible intersection with the indicated
|
|
// Subrange.
|
|
return _end < other._end;
|
|
}
|