Miscellaneous Utilities

## Namespaces

| regina
| Contains the entire Regina calculation engine.
| regina::detail
| Contains implementation details and common functionality for Regina's dimension-agnostic classes.

## Classes

class | regina::GenericBitManipulator< T, size >
| A generic class for bitwise analysis and manipulation of native data types. More...
class | regina::BitManipulator< T, size >
| An optimised class for bitwise analysis and manipulation of native data types. More...
class | regina::Bitmask
| A bitmask that can store arbitrarily many true-or-false bits. More...
class | regina::Bitmask1< T >
| A small but extremely fast bitmask class that can store up to 8 * sizeof(T) true-or-false bits. More...
class | regina::Bitmask2< T, U >
| A small but extremely fast bitmask class that can store up to 8 * sizeof(T) + 8 * sizeof(U) true-or-false bits. More...
class | regina::BoolSet
| A set of booleans. More...
class | regina::Flags< T >
| A class representing a bitwise combination of flags defined by an enumeration type. More...
class | regina::i18n::Locale
| A simple class with static routines for querying information about the current locale. More...
class | regina::i18n::IConvStreamBuffer
| An output stream buffer that translates between character encodings. More...
class | regina::i18n::IConvStream
| An output stream that converts between character encodings. More...
class | regina::ListOnCall< T >
| Offers a hard-coded list of expensive objects that should only be created if they are required. More...
class | regina::MarkedElement
| A base class for elements of MarkedVector. More...
class | regina::MarkedVector< T >
| A vector of objects with fast, space-efficient reverse lookup of array indices. More...
struct | regina::FuncNew< T >
| An adaptable generator used to create objects using default constructors. More...
struct | regina::FuncNewCopyPtr< T >
| An adaptable unary function used to create objects using copy constructors. More...
struct | regina::FuncNewCopyRef< T >
| An adaptable unary function used to create objects using copy constructors. More...
struct | regina::FuncNewClonePtr< T >
| An adaptable unary function used to create objects using the `clone()` method. More...
struct | regina::FuncDelete< T >
| An adaptable unary function used to deallocate objects. More...
class | regina::StoreValue< T >
| A Property storage policy indicating that the property should be held by value. More...
class | regina::StoreConstPtr< T >
| A Property storage policy indicating that the property should be held by constant pointer. More...
class | regina::StoreManagedPtr< T >
| A Property storage policy indicating that the property should be held by pointer and that the property wrapper will also take responsibility for memory management. More...
class | regina::Property< T, Storage >
| Stores a calculable property of an object. More...
class | regina::LessDeref< T, Comp >
| An adaptable binary function used to compare the objects to which pointers are pointing. More...
class | regina::Qitmask1< T >
| A small but extremely fast "base 4 bitmask" class that can store up to 8 * sizeof(T) "qits", each equal to 0, 1, 2 or 3. More...
class | regina::Qitmask2< T, U >
| A small but extremely fast "base 4 bitmask" class that can store up to 8 * sizeof(T) + 8 * sizeof(U) "qits", each equal to 0, 1, 2 or 3. More...
class | regina::SafePointeeBase< T >
| A base class for objects of type T to be referenceable by a SafePtr. More...
class | regina::detail::SafeRemnant< T >
| A helper class for SafePtr. More...
class | regina::SafePtr< T >
| A reference counted smart pointer that supports alternate models of ownership. More...
class | regina::TrieSet< T >
| A trie-like data structure for storing and retriving sets. More...
class | regina::Tritmask1< T >
| A small but extremely fast "ternary bitmask" class that can store up to 8 * sizeof(T) "trits", each equal to 0, 1 or 2. More...
class | regina::Tritmask2< T, U >
| A small but extremely fast "ternary bitmask" class that can store up to 8 * sizeof(T) + 8 * sizeof(U) "trits", each equal to 0, 1 or 2. More...
class | regina::xml::XMLPropertyDict
| Represents a map from property names to property values. More...
class | regina::xml::XMLParserCallback
| Provides the callbacks for an XMLParser. More...
class | regina::xml::XMLParser
| Used to parse an entire XML file. More...

## Typedefs

typedef Bitmask1< unsigned char > | regina::BitmaskLen8
| A convenience typedef that gives a small and extremely fast bitmask class capable of holding at least 8 true-or-false bits. More...
typedef Bitmask1< unsigned int > | regina::BitmaskLen16
| A convenience typedef that gives a small and extremely fast bitmask class capable of holding at least 16 true-or-false bits. More...
typedef InternalBitmaskLen32 ::Type | regina::BitmaskLen32
| A convenience typedef that gives a small and extremely fast bitmask class capable of holding at least 32 true-or-false bits. More...
typedef InternalBitmaskLen64 ::Type | regina::BitmaskLen64
| A convenience typedef that gives a small and extremely fast bitmask class capable of holding at least 64 true-or-false bits. More...
typedef BoolSet | regina::NBoolSet
| Deprecated typedef for backward compatibility. More...
typedef T | regina::Flags< T >::Enum
| The underlying enumeration type. More...
typedef std::list< const T * >::const_iterator | regina::ListOnCall< T >::iterator
| An iterator over this list. More...
typedef T * | regina::FuncNew< T >::result_type
| The return type for this generator. More...
typedef T * | regina::FuncNewCopyPtr< T >::result_type
| The return type for this unary function. More...
typedef T * | regina::FuncNewCopyRef< T >::result_type
| The return type for this unary function. More...
typedef T * | regina::FuncNewClonePtr< T >::result_type
| The return type for this unary function. More...
typedef T * | regina::FuncDelete< T >::argument_type
| The argument type for this unary function. More...
typedef void | regina::FuncDelete< T >::result_type
| The return type for this unary function. More...
typedef T * | regina::StoreManagedPtr< T >::InitType
| The type by which new values for the underlying property are passed. More...
typedef Storage< T >::InitType | regina::Property< T, Storage >::InitType
| The type by which new values for the underlying property are passed. More...
typedef Storage< T >::QueryType | regina::Property< T, Storage >::QueryType
| The type by which the property value is returned to the user. More...
typedef bool | regina::LessDeref< T, Comp >::result_type
| The result type for this binary comparison function. More...
typedef Qitmask1< unsigned char > | regina::QitmaskLen8
| A convenience typedef that gives a small and extremely fast qitmask class capable of holding at least 8 true-or-false bits. More...
typedef Qitmask1< unsigned int > | regina::QitmaskLen16
| A convenience typedef that gives a small and extremely fast qitmask class capable of holding at least 16 true-or-false bits. More...
typedef InternalQitmaskLen32 ::Type | regina::QitmaskLen32
| A convenience typedef that gives a small and extremely fast qitmask class capable of holding at least 32 true-or-false bits. More...
typedef InternalQitmaskLen64 ::Type | regina::QitmaskLen64
| A convenience typedef that gives a small and extremely fast qitmask class capable of holding at least 64 true-or-false bits. More...
typedef T | regina::SafePointeeBase< T >::SafePointeeType
| The type of object being pointed to. More...
typedef T | regina::SafePtr< T >::element_type
| The pointee type. More...
typedef Tritmask1< unsigned char > | regina::TritmaskLen8
| A convenience typedef that gives a small and extremely fast tritmask class capable of holding at least 8 true-or-false bits. More...
typedef Tritmask1< unsigned int > | regina::TritmaskLen16
| A convenience typedef that gives a small and extremely fast tritmask class capable of holding at least 16 true-or-false bits. More...
typedef InternalTritmaskLen32 ::Type | regina::TritmaskLen32
| A convenience typedef that gives a small and extremely fast tritmask class capable of holding at least 32 true-or-false bits. More...
typedef InternalTritmaskLen64 ::Type | regina::TritmaskLen64
| A convenience typedef that gives a small and extremely fast tritmask class capable of holding at least 64 true-or-false bits. More...

## Enumerations

enum | { regina::BitManipulator< T, size >::specialised = 0 }

## Functions

size_t | regina::base64Length (size_t bytes)
| Returns the number of base64 characters required to encode the given number of bytes. More...
bool | regina::isBase64 (char ch)
| Determines whether the given character is a base64 printable character as used by the base64 routines in Regina. More...
void | regina::base64Encode (const char *in, size_t inlen, char *out, size_t outlen)
| Encodes the given sequence of raw bytes in base64, and writes the results into a preallocated output buffer. More...
size_t | regina::base64Encode (const char *in, size_t inlen, char **out)
| Encodes the given sequence of raw bytes in base64, and passes back a newly allocated array containing the results. More...
bool | regina::base64Decode (const char *in, size_t inlen, char *out, size_t *outlen)
| Decodes the given sequence of base64 characters, and writes the resulting raw bytes into a preallocated output buffer. More...
bool | regina::base64Decode (const char *in, size_t inlen, char **out, size_t *outlen)
| Decodes the given sequence of base64 characters, and passes back a newly allocated array containing the results. More...
static int | regina::GenericBitManipulator< T, size >::firstBit (T x)
| Returns the index of the first `true` bit in the given integer, or -1 if the given integer is zero. More...
static int | regina::GenericBitManipulator< T, size >::lastBit (T x)
| Returns the index of the last `true` bit in the given integer, or -1 if the given integer is zero. More...
static int | regina::BitManipulator< T, size >::bits (T x)
| Returns the number of bits that are set in the given integer. More...
| regina::Bitmask::Bitmask ()
| Creates a new invalid bitmask. More...
| regina::Bitmask::Bitmask (size_t length)
| Creates a new bitmask of the given length with all bits set to `false`. More...
| regina::Bitmask::Bitmask (const Bitmask &cloneMe)
| Creates a clone of the given bitmask. More...
| regina::Bitmask::~Bitmask ()
| Destroys this bitmask. More...
bool | regina::Bitmask::get (size_t index) const
| Returns the value of the given bit of this bitmask. More...
void | regina::Bitmask::set (size_t index, bool value)
| Sets the given bit of this bitmask to the given value. More...
template<typename ForwardIterator >
void | regina::Bitmask::set (ForwardIterator indexBegin, ForwardIterator indexEnd, bool value)
| Sets all bits in the given sorted list to the given value. More...
void | regina::Bitmask::reset ()
| Sets all bits of this bitmask to `false`. More...
void | regina::Bitmask::reset (size_t length)
| Resizes this bitmask to the given length and sets all bits to `false`. More...
Bitmask & | regina::Bitmask::operator= (const Bitmask &other)
| Sets this bitmask to a copy of the given bitmask. More...
void | regina::Bitmask::truncate (size_t numBits)
| Leaves the first numBits bits of this bitmask intact, but sets all subsequent bits to `false`. More...
Bitmask & | regina::Bitmask::operator&= (const Bitmask &other)
| Sets this to the intersection of this and the given bitmask. More...
Bitmask & | regina::Bitmask::operator|= (const Bitmask &other)
| Sets this to the union of this and the given bitmask. More...
Bitmask & | regina::Bitmask::operator^= (const Bitmask &other)
| Sets this to the exclusive disjunction (XOR) of this and the given bitmask. More...
Bitmask & | regina::Bitmask::operator-= (const Bitmask &other)
| Sets this to the set difference of this and the given bitmask. More...
void | regina::Bitmask::flip ()
| Negates every bit in this bitmask. More...
bool | regina::Bitmask::operator== (const Bitmask &other) const
| Determines whether this and the given bitmask are identical. More...
bool | regina::Bitmask::lessThan (const Bitmask &other) const
| Determines whether this bitmask appears strictly before the given bitmask when bitmasks are sorted in lexicographical order. More...
bool | regina::Bitmask::operator<= (const Bitmask &other) const
| Determines whether this bitmask is entirely contained within the given bitmask. More...
bool | regina::Bitmask::inUnion (const Bitmask &x, const Bitmask &y) const
| Determines whether this bitmask is entirely contained within the union of the two given bitmasks. More...
bool | regina::Bitmask::containsIntn (const Bitmask &x, const Bitmask &y) const
| Determines whether this bitmask contains the intersection of the two given bitmasks. More...
size_t | regina::Bitmask::bits () const
| Returns the number of bits currently set to `true` in this bitmask. More...
long | regina::Bitmask::firstBit () const
| Returns the index of the first `true` bit in this bitmask, or -1 if there are no `true` bits. More...
long | regina::Bitmask::lastBit () const
| Returns the index of the last `true` bit in this bitmask, or -1 if there are no `true` bits. More...
bool | regina::Bitmask::atMostOneBit () const
| Determines whether at most one bit is set to `true` in this bitmask. More...
std::ostream & | regina::operator<< (std::ostream &out, const Bitmask &mask)
| Writes the given bitmask to the given output stream as a sequence of zeroes and ones. More...
template<typename T >
std::ostream & | regina::operator<< (std::ostream &out, const Bitmask1< T > &mask)
| Writes the given bitmask to the given output stream as a sequence of zeroes and ones. More...
| regina::Bitmask1< T >::Bitmask1 ()
| Creates a new bitmask with all bits set to `false`. More...
| regina::Bitmask1< T >::Bitmask1 (size_t)
| Creates a new bitmask with all bits set to `false`. More...
| regina::Bitmask1< T >::Bitmask1 (const Bitmask1< T > &cloneMe)
| Creates a clone of the given bitmask. More...
void | regina::Bitmask1< T >::reset ()
| Sets all bits of this bitmask to `false`. More...
void | regina::Bitmask1< T >::reset (size_t)
| Sets all bits of this bitmask to `false`. More...
Bitmask1< T > & | regina::Bitmask1< T >::operator= (const Bitmask1< T > &other)
| Sets this bitmask to a copy of the given bitmask. More...
void | regina::Bitmask1< T >::truncate (size_t numBits)
| Leaves the first numBits bits of this bitmask intact, but sets all subsequent bits to `false`. More...
bool | regina::Bitmask1< T >::get (size_t index) const
| Returns the value of the given bit of this bitmask. More...
void | regina::Bitmask1< T >::set (size_t index, bool value)
| Sets the given bit of this bitmask to the given value. More...
template<typename ForwardIterator >
void | regina::Bitmask1< T >::set (ForwardIterator indexBegin, ForwardIterator indexEnd, bool value)
| Sets all bits in the given sorted list to the given value. More...
Bitmask1< T > & | regina::Bitmask1< T >::operator&= (const Bitmask1< T > &other)
| Sets this to the intersection of this and the given bitmask. More...
Bitmask1< T > & | regina::Bitmask1< T >::operator|= (const Bitmask1< T > &other)
| Sets this to the union of this and the given bitmask. More...
Bitmask1< T > & | regina::Bitmask1< T >::operator^= (const Bitmask1< T > &other)
| Sets this to the exclusive disjunction (XOR) of this and the given bitmask. More...
Bitmask1< T > & | regina::Bitmask1< T >::operator-= (const Bitmask1< T > &other)
| Sets this to the set difference of this and the given bitmask. More...
void | regina::Bitmask1< T >::flip ()
| Negates every bit in this bitmask. More...
bool | regina::Bitmask1< T >::operator== (const Bitmask1< T > &other) const
| Determines whether this and the given bitmask are identical. More...
bool | regina::Bitmask1< T >::lessThan (const Bitmask1< T > &other) const
| Determines whether this bitmask appears strictly before the given bitmask when bitmasks are sorted in lexicographical order. More...
bool | regina::Bitmask1< T >::operator<= (const Bitmask1< T > &other) const
| Determines whether this bitmask is entirely contained within the given bitmask. More...
bool | regina::Bitmask1< T >::inUnion (const Bitmask1< T > &x, const Bitmask1< T > &y) const
| Determines whether this bitmask is entirely contained within the union of the two given bitmasks. More...
bool | regina::Bitmask1< T >::containsIntn (const Bitmask1< T > &x, const Bitmask1< T > &y) const
| Determines whether this bitmask contains the intersection of the two given bitmasks. More...
size_t | regina::Bitmask1< T >::bits () const
| Returns the number of bits currently set to `true` in this bitmask. More...
long | regina::Bitmask1< T >::firstBit () const
| Returns the index of the first `true` bit in this bitmask, or -1 if there are no `true` bits. More...
long | regina::Bitmask1< T >::lastBit () const
| Returns the index of the last `true` bit in this bitmask, or -1 if there are no `true` bits. More...
bool | regina::Bitmask1< T >::atMostOneBit () const
| Determines whether at most one bit is set to `true` in this bitmask. More...
template<typename T , typename U >
std::ostream & | regina::operator<< (std::ostream &out, const Bitmask2< T, U > &mask)
| Writes the given bitmask to the given output stream as a sequence of zeroes and ones. More...
| regina::Bitmask2< T, U >::Bitmask2 ()
| Creates a new bitmask with all bits set to `false`. More...
| regina::Bitmask2< T, U >::Bitmask2 (size_t)
| Creates a new bitmask with all bits set to `false`. More...
| regina::Bitmask2< T, U >::Bitmask2 (const Bitmask2< T, U > &cloneMe)
| Creates a clone of the given bitmask. More...
void | regina::Bitmask2< T, U >::reset ()
| Sets all bits of this bitmask to `false`. More...
void | regina::Bitmask2< T, U >::reset (size_t)
| Sets all bits of this bitmask to `false`. More...
Bitmask2< T, U > & | regina::Bitmask2< T, U >::operator= (const Bitmask2< T, U > &other)
| Sets this bitmask to a copy of the given bitmask. More...
void | regina::Bitmask2< T, U >::truncate (size_t numBits)
| Leaves the first numBits bits of this bitmask intact, but sets all subsequent bits to `false`. More...
bool | regina::Bitmask2< T, U >::get (size_t index) const
| Returns the value of the given bit of this bitmask. More...
void | regina::Bitmask2< T, U >::set (size_t index, bool value)
| Sets the given bit of this bitmask to the given value. More...
template<typename ForwardIterator >
void | regina::Bitmask2< T, U >::set (ForwardIterator indexBegin, ForwardIterator indexEnd, bool value)
| Sets all bits in the given sorted list to the given value. More...
Bitmask2< T, U > & | regina::Bitmask2< T, U >::operator&= (const Bitmask2< T, U > &other)
| Sets this to the intersection of this and the given bitmask. More...
Bitmask2< T, U > & | regina::Bitmask2< T, U >::operator|= (const Bitmask2< T, U > &other)
| Sets this to the union of this and the given bitmask. More...
Bitmask2< T, U > & | regina::Bitmask2< T, U >::operator^= (const Bitmask2< T, U > &other)
| Sets this to the exclusive disjunction (XOR) of this and the given bitmask. More...
Bitmask2< T, U > & | regina::Bitmask2< T, U >::operator-= (const Bitmask2< T, U > &other)
| Sets this to the set difference of this and the given bitmask. More...
void | regina::Bitmask2< T, U >::flip ()
| Negates every bit in this bitmask. More...
bool | regina::Bitmask2< T, U >::operator== (const Bitmask2< T, U > &other) const
| Determines whether this and the given bitmask are identical. More...
bool | regina::Bitmask2< T, U >::lessThan (const Bitmask2< T, U > &other) const
| Determines whether this bitmask appears strictly before the given bitmask when bitmasks are sorted in lexicographical order. More...
bool | regina::Bitmask2< T, U >::operator<= (const Bitmask2< T, U > &other) const
| Determines whether this bitmask is entirely contained within the given bitmask. More...
bool | regina::Bitmask2< T, U >::inUnion (const Bitmask2< T, U > &x, const Bitmask2< T, U > &y) const
| Determines whether this bitmask is entirely contained within the union of the two given bitmasks. More...
bool | regina::Bitmask2< T, U >::containsIntn (const Bitmask2< T, U > &x, const Bitmask2< T, U > &y) const
| Determines whether this bitmask contains the intersection of the two given bitmasks. More...
size_t | regina::Bitmask2< T, U >::bits () const
| Returns the number of bits currently set to `true` in this bitmask. More...
long | regina::Bitmask2< T, U >::firstBit () const
| Returns the index of the first `true` bit in this bitmask, or -1 if there are no `true` bits. More...
long | regina::Bitmask2< T, U >::lastBit () const
| Returns the index of the last `true` bit in this bitmask, or -1 if there are no `true` bits. More...
bool | regina::Bitmask2< T, U >::atMostOneBit () const
| Determines whether at most one bit is set to `true` in this bitmask. More...
| regina::BoolSet::BoolSet ()
| Creates a new empty set. More...
| regina::BoolSet::BoolSet (bool member)
| Creates a set containing a single member as given. More...
| regina::BoolSet::BoolSet (const BoolSet &cloneMe)
| Creates a set equal to the given set. More...
| regina::BoolSet::BoolSet (bool insertTrue, bool insertFalse)
| Creates a set specifying whether `true` and/or `false` should be a member. More...
bool | regina::BoolSet::hasTrue () const
| Determines if `true` is a member of this set. More...
bool | regina::BoolSet::hasFalse () const
| Determines if `false` is a member of this set. More...
bool | regina::BoolSet::contains (bool value) const
| Determines if the given boolean is a member of this set. More...
void | regina::BoolSet::insertTrue ()
| Inserts `true` into this set if it is not already present. More...
void | regina::BoolSet::insertFalse ()
| Inserts `false` into this set if it is not already present. More...
void | regina::BoolSet::removeTrue ()
| Removes `true` from this set if it is present. More...
void | regina::BoolSet::removeFalse ()
| Removes `false` from this set if it is present. More...
void | regina::BoolSet::empty ()
| Removes all elements from this set. More...
void | regina::BoolSet::fill ()
| Places both `true` and `false` into this set if they are not already present. More...
bool | regina::BoolSet::operator== (const BoolSet &other) const
| Determines if this set is equal to the given set. More...
bool | regina::BoolSet::operator!= (const BoolSet &other) const
| Determines if this set is not equal to the given set. More...
bool | regina::BoolSet::operator< (const BoolSet &other) const
| Determines if this set is a proper subset of the given set. More...
bool | regina::BoolSet::operator> (const BoolSet &other) const
| Determines if this set is a proper superset of the given set. More...
bool | regina::BoolSet::operator<= (const BoolSet &other) const
| Determines if this set is a subset of (possibly equal to) the given set. More...
bool | regina::BoolSet::operator>= (const BoolSet &other) const
| Determines if this set is a superset of (possibly equal to) the given set. More...
BoolSet & | regina::BoolSet::operator= (const BoolSet &cloneMe)
| Sets this set to be identical to the given set. More...
BoolSet & | regina::BoolSet::operator= (bool member)
| Sets this set to the single member set containing the given element. More...
BoolSet & | regina::BoolSet::operator|= (const BoolSet &other)
| Sets this set to be the union of this and the given set. More...
BoolSet & | regina::BoolSet::operator&= (const BoolSet &other)
| Sets this set to be the intersection of this and the given set. More...
BoolSet & | regina::BoolSet::operator^= (const BoolSet &other)
| Sets this set to be the symmetric difference of this and the given set. More...
BoolSet | regina::BoolSet::operator| (const BoolSet &other) const
| Returns the union of this set with the given set. More...
BoolSet | regina::BoolSet::operator& (const BoolSet &other) const
| Returns the intersection of this set with the given set. More...
BoolSet | regina::BoolSet::operator^ (const BoolSet &other) const
| Returns the symmetric difference of this set and the given set. More...
BoolSet | regina::BoolSet::operator~ () const
| Returns the complement of this set. More...
unsigned char | regina::BoolSet::byteCode () const
| Returns the byte code representing this boolean set. More...
void | regina::BoolSet::setByteCode (unsigned char code)
| Sets this boolean set to that represented by the given byte code. More...
static BoolSet | regina::BoolSet::fromByteCode (unsigned char code)
| Creates a boolean set from the given byte code. More...
std::ostream & | regina::operator<< (std::ostream &out, const BoolSet &set)
| Writes the given boolean set to the given output stream. More...
| regina::Flags< T >::Flags ()
| Creates an empty flag set, with no flags set at all. More...
| regina::Flags< T >::Flags (T init)
| Creates a flag set initialised to the given value. More...
| regina::Flags< T >::Flags (const Flags< T > &init)
| Creates a clone of the given flag set. More...
int | regina::Flags< T >::intValue () const
| Returns the integer representation of this set. More...
static Flags< T > | regina::Flags< T >::fromInt (int value)
| Returns the set corresponding to the given integer value. More...
bool | regina::Flags< T >::has (T flag) const
| Returns whether the given flag is set. More...
bool | regina::Flags< T >::has (const Flags< T > &rhs) const
| Returns whether all of the flags in the given set are set. More...
bool | regina::Flags< T >::operator== (T rhs) const
| Determines whether this set is precisely equal to the given flag. More...
bool | regina::Flags< T >::operator== (const Flags< T > &rhs) const
| Determines whether this set is precisely equal to the given flag set. More...
bool | regina::Flags< T >::operator!= (T rhs) const
| Determines whether this set is not equal to the given flag. More...
bool | regina::Flags< T >::operator!= (const Flags< T > &rhs) const
| Determines whether this set is not equal to the given flag set. More...
Flags< T > & | regina::Flags< T >::operator= (T rhs)
| Sets this flag set to contain precisely the given flag only. More...
Flags< T > & | regina::Flags< T >::operator= (const Flags< T > &rhs)
| Sets this flag set to contain a copy of the given flag set. More...
Flags< T > & | regina::Flags< T >::operator|= (T rhs)
| Changes this flag set by taking a bitwise OR with the given flag. More...
Flags< T > & | regina::Flags< T >::operator|= (const Flags< T > &rhs)
| Changes this flag set by taking a bitwise OR with the given flag set. More...
Flags< T > & | regina::Flags< T >::operator&= (T rhs)
| Changes this flag set by taking a bitwise AND with the given flag. More...
Flags< T > & | regina::Flags< T >::operator&= (const Flags< T > &rhs)
| Changes this flag set by taking a bitwise AND with the given flag set. More...
Flags< T > & | regina::Flags< T >::operator^= (T rhs)
| Changes this flag set by taking a bitwise XOR with the given flag. More...
Flags< T > & | regina::Flags< T >::operator^= (const Flags< T > &rhs)
| Changes this flag set by taking a bitwise XOR with the given flag set. More...
Flags< T > | regina::Flags< T >::operator| (T rhs) const
| Returns the bitwise OR of this set and the given flag. More...
Flags< T > | regina::Flags< T >::operator| (const Flags< T > &rhs) const
| Returns the bitwise OR of this and the given flag set. More...
Flags< T > | regina::Flags< T >::operator& (T rhs) const
| Returns the bitwise AND of this set and the given flag. More...
Flags< T > | regina::Flags< T >::operator& (const Flags< T > &rhs) const
| Returns the bitwise AND of this and the given flag set. More...
Flags< T > | regina::Flags< T >::operator^ (T rhs) const
| Returns the bitwise XOR of this set and the given flag. More...
Flags< T > | regina::Flags< T >::operator^ (const Flags< T > &rhs) const
| Returns the bitwise XOR of this and the given flag set. More...
void | regina::Flags< T >::clear (T rhs)
| Clears all bits from this set that appear in the given flag. More...
void | regina::Flags< T >::clear (const Flags< T > &rhs)
| Clears all bits from this set that appear in the given set. More...
void | regina::Flags< T >::ensureOne (T default_, T other)
| Adjust this set so that exactly one and only one of the two given flags are included. More...
void | regina::Flags< T >::ensureOne (T default_, T second, T last)
| Adjust this set so that exactly one and only one of the three given flags are included. More...
void | regina::Flags< T >::ensureOne (T default_, T second, T third, T last)
| Adjust this set so that exactly one and only one of the four given flags are included. More...
static const char * | regina::i18n::Locale::codeset ()
| Returns the character encoding used in the current locale. More...
| regina::i18n::Locale::Locale ()=delete
| Disable the default constructor, since all routines are static. More...
| regina::i18n::IConvStreamBuffer::IConvStreamBuffer ()
| Creates a new stream buffer. More...
| regina::i18n::IConvStreamBuffer::~IConvStreamBuffer ()
| Destroys this stream buffer. More...
IConvStreamBuffer * | regina::i18n::IConvStreamBuffer::open (std::ostream &dest, const char *srcCode, const char *destCode)
| Opens a new stream buffer that wraps around the given output stream. More...
IConvStreamBuffer * | regina::i18n::IConvStreamBuffer::close () throw ()
| Closes this stream buffer. More...
int_type | regina::i18n::IConvStreamBuffer::overflow (int_type c)
| Sends buffered data to the destination output stream, converting between character sets en route. More...
int_type | regina::i18n::IConvStreamBuffer::underflow ()
| Simply returns EOF (since this is not an input stream). More...
int | regina::i18n::IConvStreamBuffer::sync ()
| Flushes all output buffers. More...
| regina::i18n::IConvStream::IConvStream (std::ostream &dest, const char *srcCode, const char *destCode)
| Creates a new IConvStream; see the class notes for details. More...
| regina::ListOnCall< T >::ListOnCall ()
| Creates a new list structure. More...
virtual | regina::ListOnCall< T >::~ListOnCall ()
| Destroys this list and all of the items it contains. More...
iterator | regina::ListOnCall< T >::begin () const
| Returns an iterator pointing to the first item in this list. More...
iterator | regina::ListOnCall< T >::end () const
| Returns an iterator pointing past the end of this list (i.e., just after the last item). More...
void | regina::ListOnCall< T >::insert (T *item)
| Adds the given item to the end of this list. More...
virtual void | regina::ListOnCall< T >::initialise ()=0
| Fills this list with items. More...
size_t | regina::MarkedElement::markedIndex () const
| Returns the index at which this object is stored in an MarkedVector. More...
| regina::MarkedVector< T >::MarkedVector ()
| Constructs a new empty vector. More...
const std::vector< T * > & | regina::MarkedVector< T >::operator() () const
| Casts this vector to a const std::vector, thus providing access to the entire const functionality of std::vector. More...
void | regina::MarkedVector< T >::push_back (T *item)
| Pushes the given item onto the end of this vector. More...
std::vector< T * >::iterator | regina::MarkedVector< T >::erase (typename std::vector< T * >::iterator pos)
| Erases the item at the given position in this vector. More...
std::vector< T * >::iterator | regina::MarkedVector< T >::erase (typename std::vector< T * >::iterator first, typename std::vector< T * >::iterator last)
| Erases all items in the given range in this vector. More...
void | regina::MarkedVector< T >::swap (MarkedVector< T > &other)
| Swaps the contents of this and the given vector. More...
template<typename Iterator >
void | regina::MarkedVector< T >::refill (Iterator begin, Iterator end)
| Empties this vector and refills it with the given range of items. More...
T * | regina::FuncNew< T >::operator() () const
| Creates a new object using the default constructor. More...
T * | regina::FuncNewCopyPtr< T >::operator() (const T *ptr) const
| Creates a new object using the copy constructor. More...
T * | regina::FuncNewCopyRef< T >::operator() (const T &obj) const
| Creates a new object using the copy constructor. More...
T * | regina::FuncNewClonePtr< T >::operator() (const T *ptr) const
| Creates a new object using the `clone()` method. More...
void | regina::FuncDelete< T >::operator() (T *ptr) const
| Calls `delete` upon the given pointer. More...
void | regina::StoreValue< T >::clear ()
| Cleans up any currently held value before the property value is changed or cleared. More...
void | regina::StoreValue< T >::swap (StoreValue< T > &other)
| Swaps this with the given value. More...
| regina::StoreConstPtr< T >::StoreConstPtr ()
| Constructor that sets the held pointer to 0. More...
void | regina::StoreConstPtr< T >::clear ()
| Cleans up any currently held value before the property value is changed or cleared. More...
void | regina::StoreConstPtr< T >::swap (StoreConstPtr< T > &other)
| Swaps this with the given value. More...
| regina::StoreManagedPtr< T >::StoreManagedPtr ()
| Constructor that sets the held pointer to 0. More...
void | regina::StoreManagedPtr< T >::clear ()
| Cleans up any currently held value before the property value is changed or cleared. More...
| regina::StoreManagedPtr< T >::~StoreManagedPtr ()
| Destroys the currently held value if one exists. More...
void | regina::StoreManagedPtr< T >::swap (StoreManagedPtr< T > &other)
| Swaps this with the given value. More...
| regina::Property< T, Storage >::Property ()
| Constructor. More...
bool | regina::Property< T, Storage >::known () const
| Returns whether or not this property is currently marked as known. More...
QueryType | regina::Property< T, Storage >::value () const
| Returns the current value of this property. More...
void | regina::Property< T, Storage >::clear ()
| Marks this property as unknown. More...
QueryType | regina::Property< T, Storage >::operator= (InitType newValue)
| Assigns a new value to this property. More...
const Property< T, Storage > & | regina::Property< T, Storage >::operator= (const Property< T, Storage > &newValue)
| Copies the given property into this property. More...
void | regina::Property< T, Storage >::swap (Property< T, Storage > &other)
| Swaps this with the given property. More...
template<typename T >
T * | regina::clonePtr (T *cloneMe)
| A simple routine for cloning an object if and only if it exists. More...
template<typename T >
T * | regina::clonePtr (const std::unique_ptr< T > &cloneMe)
| A simple routine for cloning an object if and only if it exists. More...
bool | regina::LessDeref< T, Comp >::operator() (const T *ptr1, const T *ptr2) const
| Compares the objects to which the given pointers are pointing. More...
template<typename T >
std::ostream & | regina::operator<< (std::ostream &out, const Qitmask1< T > &mask)
| Writes the given qitmask to the given output stream as a sequence of digits (0, 1, 2 and/or 3). More...
| regina::Qitmask1< T >::Qitmask1 ()
| Creates a new qitmask with all qits set to 0. More...
| regina::Qitmask1< T >::Qitmask1 (const Qitmask1< T > &cloneMe)
| Creates a clone of the given qitmask. More...
void | regina::Qitmask1< T >::reset ()
| Sets all qits of this qitmask to 0. More...
Qitmask1< T > & | regina::Qitmask1< T >::operator= (const Qitmask1< T > &other)
| Sets this qitmask to a copy of the given qitmask. More...
char | regina::Qitmask1< T >::get (unsigned index) const
| Returns the value of the given qit in this qitmask. More...
void | regina::Qitmask1< T >::set (unsigned index, char value)
| Sets the given qit of this qitmask to the given value. More...
bool | regina::Qitmask1< T >::empty () const
| Determines whether this qitmask contains all zeroes. More...
bool | regina::Qitmask1< T >::nonEmpty () const
| Determines whether this qitmask contains at least one non-zero qit. More...
bool | regina::Qitmask1< T >::has3 () const
| Determines whether this qitmask contains at least one qit with value 3. More...
Qitmask1< T > & | regina::Qitmask1< T >::operator+= (const Qitmask1< T > &rhs)
| Sets this to the sum of this and the given qitmask. More...
Qitmask1< T > & | regina::Qitmask1< T >::operator-= (const Qitmask1< T > &rhs)
| Sets this to the difference of this and the given qitmask. More...
bool | regina::Qitmask1< T >::operator== (const Qitmask1< T > &other) const
| Determines whether this and the given qitmask are identical. More...
bool | regina::Qitmask1< T >::hasNonZeroMatch (const Qitmask1< T > &other) const
| Determines whether there is some index at which both this and the given qitmask both have non-zero qits. More...
template<typename T , typename U >
std::ostream & | regina::operator<< (std::ostream &out, const Qitmask2< T, U > &mask)
| Writes the given qitmask to the given output stream as a sequence of digits (0, 1, 2 and/or 3). More...
| regina::Qitmask2< T, U >::Qitmask2 ()
| Creates a new qitmask with all qits set to 0. More...
| regina::Qitmask2< T, U >::Qitmask2 (const Qitmask2< T, U > &cloneMe)
| Creates a clone of the given qitmask. More...
void | regina::Qitmask2< T, U >::reset ()
| Sets all qits of this qitmask to 0. More...
Qitmask2< T, U > & | regina::Qitmask2< T, U >::operator= (const Qitmask2< T, U > &other)
| Sets this qitmask to a copy of the given qitmask. More...
char | regina::Qitmask2< T, U >::get (unsigned index) const
| Returns the value of the given qit in this qitmask. More...
void | regina::Qitmask2< T, U >::set (unsigned index, char value)
| Sets the given qit of this qitmask to the given value. More...
bool | regina::Qitmask2< T, U >::empty () const
| Determines whether this qitmask contains all zeroes. More...
bool | regina::Qitmask2< T, U >::nonEmpty () const
| Determines whether this qitmask contains at least one non-zero qit. More...
bool | regina::Qitmask2< T, U >::has3 () const
| Determines whether this qitmask contains at least one qit with value 3. More...
Qitmask2< T, U > & | regina::Qitmask2< T, U >::operator+= (const Qitmask2< T, U > &rhs)
| Sets this to the sum of this and the given qitmask. More...
Qitmask2< T, U > & | regina::Qitmask2< T, U >::operator-= (const Qitmask2< T, U > &rhs)
| Sets this to the difference of this and the given qitmask. More...
bool | regina::Qitmask2< T, U >::operator== (const Qitmask2< T, U > &other) const
| Determines whether this and the given qitmask are identical. More...
bool | regina::Qitmask2< T, U >::hasNonZeroMatch (const Qitmask2< T, U > &other) const
| Determines whether there is some index at which both this and the given qitmask both have non-zero qits. More...
| regina::SafePointeeBase< T >::SafePointeeBase (const SafePointeeBase &)=delete
| Prevent derived classes from accidentally calling the copy constructor. More...
| regina::SafePointeeBase< T >::~SafePointeeBase ()
| Destructor. More...
SafePointeeBase & | regina::SafePointeeBase< T >::operator= (const SafePointeeBase &)=delete
| Prevent derived classes from accidentally calling the assignment operator. More...
| regina::SafePointeeBase< T >::SafePointeeBase ()
| Default constructor. More...
| regina::SafePtr< T >::SafePtr ()
| Constructs a new null pointer. More...
| regina::SafePtr< T >::SafePtr (T *object)
| Constructs a new safe pointer that points to the given object. More...
template<class Y >
| regina::SafePtr< T >::SafePtr (const SafePtr< Y > &other)
| Copy constructor. More...
T * | regina::SafePtr< T >::get () const
| Returns a raw pointer to the pointee, or `null` if the pointee has already been destroyed. More...
| regina::SafePtr< T >::operator bool () const
| Returns `true` if the pointee is non-null and has not yet been destroyed. More...
void | regina::SafePtr< T >::reset (T *object=0)
| Resets this to point to the given object. More...
SafePtr< T > & | regina::SafePtr< T >::operator= (const SafePtr< T > &)=delete
| Disable the default assignment operator. More...
template<class T >
T * | boost::get_pointer (regina::SafePtr< T > const &ptr)
| Extracts a raw pointer from the given safe pointer. More...
static SafeRemnant< T > * | regina::detail::SafeRemnant< T >::getOrCreate (T *object)
| Given an object deriving from SafePointeeBase, find or create the remnant corresponding to the object. More...
| regina::detail::SafeRemnant< T >::~SafeRemnant ()
| Destroys this remnant. More...
T * | regina::detail::SafeRemnant< T >::get () const
| Dereference this remnant. More...
void | regina::detail::SafeRemnant< T >::expire ()
| Expire the remnant so that it can no longer be dereferenced. More...
char * | regina::duplicate (const std::string &str)
| Creates a new C string that is a duplicate of the given C++ string. More...
bool | regina::startsWith (const std::string &str, const std::string &prefix)
| Determines whether the given C++ string begins with the given prefix. More...
std::string | regina::stripWhitespace (const std::string &str)
| Strips all whitespace from the beginning and end of the given C++ string. More...
bool | regina::valueOf (const std::string &str, int8_t &dest)
| Converts the entire given string to an 8-bit integer and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, uint8_t &dest)
| Converts the entire given string to an unsigned 8-bit integer and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, short &dest)
| Converts the entire given string to a short integer and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, unsigned short &dest)
| Converts the entire given string to an unsigned short integer and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, int &dest)
| Converts the entire given string to an integer and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, unsigned &dest)
| Converts the entire given string to an unsigned integer and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, long &dest)
| Converts the entire given string to a long integer and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, unsigned long &dest)
| Converts the entire given string to an unsigned long integer and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, long long &dest)
| Converts the entire given string to a long long integer and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, unsigned long long &dest)
| Converts the entire given string to an unsigned long long integer and reports whether this conversion was successful. More...
template<bool supportInfinity>
bool | regina::valueOf (const std::string &str, IntegerBase< supportInfinity > &dest)
| Converts the entire given string to an arbitrary precision integer and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, double &dest)
| Converts the entire given string to a double precision real number and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, bool &dest)
| Converts the entire given string to a boolean and reports whether this conversion was successful. More...
bool | regina::valueOf (const std::string &str, BoolSet &dest)
| Converts the entire given string to a set of booleans and reports whether this conversion was successful. More...
template<class OutputIterator >
unsigned | regina::basicTokenise (OutputIterator results, const std::string &str)
| Decomposes the given string into tokens. More...
std::string | regina::stringToToken (const char *str)
| Returns a token derived from the given string. More...
std::string | regina::stringToToken (const std::string &str)
| Returns a token derived from the given string. More...
template<typename T >
std::string | regina::superscript (T value)
| Converts the given native C++ integer into a unicode superscript string. More...
template<typename T >
std::string | regina::subscript (T value)
| Converts the given native C++ integer into a unicode subscript string. More...
| regina::TrieSet< T >::TrieSet ()
| Constructs an empty collection of sets. More...
| regina::TrieSet< T >::~TrieSet ()
| Destroys this collection of sets. More...
void | regina::TrieSet< T >::insert (const T &entry)
| Insert the given set into this collection. More...
bool | regina::TrieSet< T >::hasSubset (const T &superset, unsigned long universeSize) const
| Determines whether this collection of sets contains any subset of the argument superset. More...
bool | regina::TrieSet< T >::hasExtraSuperset (const T &subset, const T &exc1, const T &exc2, unsigned long universeSize) const
| Performs the particular superset search required by the double description method. More...
| regina::Tritmask1< T >::Tritmask1 ()
| Creates a new tritmask with all trits set to 0. More...
| regina::Tritmask1< T >::Tritmask1 (const Tritmask1< T > &cloneMe)
| Creates a clone of the given tritmask. More...
void | regina::Tritmask1< T >::reset ()
| Sets all trits of this tritmask to 0. More...
Tritmask1< T > & | regina::Tritmask1< T >::operator= (const Tritmask1< T > &other)
| Sets this tritmask to a copy of the given tritmask. More...
char | regina::Tritmask1< T >::get (unsigned index) const
| Returns the value of the given trit in this tritmask. More...
void | regina::Tritmask1< T >::set (unsigned index, char value)
| Sets the given trit of this tritmask to the given value. More...
bool | regina::Tritmask1< T >::empty () const
| Determines whether this tritmask contains all zeroes. More...
bool | regina::Tritmask1< T >::nonEmpty () const
| Determines whether this tritmask contains at least one non-zero trit. More...
bool | regina::Tritmask1< T >::has2 () const
| Determines whether this tritmask contains at least one trit with value 2. More...
Tritmask1< T > & | regina::Tritmask1< T >::minWith (const Tritmask1< T > &rhs)
| Sets this to the minimum of this and the given tritmask. More...
Tritmask1< T > & | regina::Tritmask1< T >::maxWith (const Tritmask1< T > &rhs)
| Sets this to the maximum of this and the given tritmask. More...
Tritmask1< T > & | regina::Tritmask1< T >::operator+= (const Tritmask1< T > &rhs)
| Sets this to the sum of this and the given tritmask. More...
Tritmask1< T > & | regina::Tritmask1< T >::operator-= (const Tritmask1< T > &rhs)
| Sets this to the difference of this and the given tritmask. More...
bool | regina::Tritmask1< T >::operator== (const Tritmask1< T > &other) const
| Determines whether this and the given tritmask are identical. More...
template<typename T >
std::ostream & | regina::operator<< (std::ostream &out, const Tritmask1< T > &mask)
| Writes the given tritmask to the given output stream as a sequence of digits (0, 1 and/or 2). More...
| regina::Tritmask2< T, U >::Tritmask2 ()
| Creates a new tritmask with all trits set to 0. More...
| regina::Tritmask2< T, U >::Tritmask2 (const Tritmask2< T, U > &cloneMe)
| Creates a clone of the given tritmask. More...
void | regina::Tritmask2< T, U >::reset ()
| Sets all trits of this tritmask to 0. More...
Tritmask2< T, U > & | regina::Tritmask2< T, U >::operator= (const Tritmask2< T, U > &other)
| Sets this tritmask to a copy of the given tritmask. More...
char | regina::Tritmask2< T, U >::get (unsigned index) const
| Returns the value of the given trit in this tritmask. More...
void | regina::Tritmask2< T, U >::set (unsigned index, char value)
| Sets the given trit of this tritmask to the given value. More...
bool | regina::Tritmask2< T, U >::empty () const
| Determines whether this tritmask contains all zeroes. More...
bool | regina::Tritmask2< T, U >::nonEmpty () const
| Determines whether this tritmask contains at least one non-zero trit. More...
bool | regina::Tritmask2< T, U >::has2 () const
| Determines whether this tritmask contains at least one trit with value 2. More...
Tritmask2< T, U > & | regina::Tritmask2< T, U >::minWith (const Tritmask2< T, U > &rhs)
| Sets this to the minimum of this and the given tritmask. More...
Tritmask2< T, U > & | regina::Tritmask2< T, U >::maxWith (const Tritmask2< T, U > &rhs)
| Sets this to the maximum of this and the given tritmask. More...
Tritmask2< T, U > & | regina::Tritmask2< T, U >::operator+= (const Tritmask2< T, U > &rhs)
| Sets this to the sum of this and the given tritmask. More...
Tritmask2< T, U > & | regina::Tritmask2< T, U >::operator-= (const Tritmask2< T, U > &rhs)
| Sets this to the difference of this and the given tritmask. More...
bool | regina::Tritmask2< T, U >::operator== (const Tritmask2< T, U > &other) const
| Determines whether this and the given tritmask are identical. More...
template<typename T , typename U >
std::ostream & | regina::operator<< (std::ostream &out, const Tritmask2< T, U > &mask)
| Writes the given tritmask to the given output stream as a sequence of digits (0, 1 and/or 2). More...
| regina::xml::XMLPropertyDict::XMLPropertyDict ()
| Create a new map. More...
const std::string & | regina::xml::XMLPropertyDict::lookup (const std::string &key) const
| Return a value for the given key, or the empty string if the key does not exist in the map. More...
virtual | regina::xml::XMLParserCallback::~XMLParserCallback ()
| Default destructor that does nothing. More...
virtual void | regina::xml::XMLParserCallback::start_document (XMLParser *parser)
| Called at the start of the document. More...
virtual void | regina::xml::XMLParserCallback::end_document ()
| Called when the document is finalised. More...
virtual void | regina::xml::XMLParserCallback::start_element (const std::string &n, const regina::xml::XMLPropertyDict &p)
| Called when an element's opening tag is encountered. More...
virtual void | regina::xml::XMLParserCallback::end_element (const std::string &n)
| Called when an element's closing tag is encountered. More...
virtual void | regina::xml::XMLParserCallback::characters (const std::string &s)
| Called when characters are encountered. More...
virtual void | regina::xml::XMLParserCallback::comment (const std::string &s)
| Called when a comment is encountered. More...
virtual void | regina::xml::XMLParserCallback::warning (const std::string &s)
| Called when a parser warning occurs. More...
virtual void | regina::xml::XMLParserCallback::error (const std::string &s)
| Called when a parser error occurs. More...
virtual void | regina::xml::XMLParserCallback::fatal_error (const std::string &s)
| Called when a parser fatal error occurs. More...
| regina::xml::XMLParser::XMLParser (XMLParserCallback &callback)
| Creates a new XML parser. More...
virtual | regina::xml::XMLParser::~XMLParser ()
| Destroys this XML parser. More...
void | regina::xml::XMLParser::parse_chunk (const std::string &s)
| Parses the given chunk of XML. More...
void | regina::xml::XMLParser::finish ()
| Signals that there are no more XML chunks to parse. More...
static void | regina::xml::XMLParser::parse_stream (XMLParserCallback &callback, std::istream &file, unsigned chunkSize=1024)
| Parses an entire XML file. More...
std::string | regina::xml::xmlString (xmlChar *str, bool free=true)
| Converts the given string from libxml into a C++ string, optionally deallocating the original libxml string. More...
std::string | regina::xml::xmlEncodeSpecialChars (const std::string &original)
| Returns the given string with special characters converted to XML entities. More...
std::string | regina::xml::xmlEncodeComment (const std::string &comment)
| Returns the given string encoded so it is suitable for use inside an XML comment. More...
template<class T >
std::string | regina::xml::xmlValueTag (const std::string &tagName, const T &value)
| Returns an XML tag with a single property containing the given value. More...

## Variables

const typedef T * | regina::FuncNewCopyPtr< T >::argument_type
| The argument type for this unary function. More...
const typedef T & | regina::FuncNewCopyRef< T >::argument_type
| The argument type for this unary function. More...
const typedef T * | regina::FuncNewClonePtr< T >::argument_type
| The argument type for this unary function. More...
const typedef T & | regina::StoreValue< T >::InitType
| The type by which new values for the underlying property are passed. More...
const typedef T & | regina::StoreValue< T >::QueryType
| The type by which the property value is returned to the user. More...
const typedef T * | regina::StoreConstPtr< T >::InitType
| The type by which new values for the underlying property are passed. More...
const typedef T * | regina::StoreConstPtr< T >::QueryType
| The type by which the property value is returned to the user. More...
const typedef T * | regina::StoreManagedPtr< T >::QueryType
| The type by which the property value is returned to the user. More...
const typedef T * | regina::LessDeref< T, Comp >::first_argument_type
| The first argument type for this binary function. More...
const typedef T * | regina::LessDeref< T, Comp >::second_argument_type
| The second argument type for this binary function. More...
static const BoolSet | regina::BoolSet::sNone
| The empty set. More...
static const BoolSet | regina::BoolSet::sTrue
| The set containing only `true`. More...
static const BoolSet | regina::BoolSet::sFalse
| The set containing only `false`. More...
static const BoolSet | regina::BoolSet::sBoth
| The set containing both `true` and `false`. More...
T | regina::StoreValue< T >::value_
| The held property value. More...
const T * | regina::StoreConstPtr< T >::value_
| The held property value. More...
T * | regina::StoreManagedPtr< T >::value_
| The held property value. More...

## Friends

template<typename T >
class | regina::MarkedElement::MarkedVector
| Allow only MarkedVector to edit the array index. More...
class | regina::SafePointeeBase< T >::detail::SafeRemnant< T >
std::ostream & | regina::Bitmask::operator<< (std::ostream &out, const Bitmask &mask)
| Writes the given bitmask to the given output stream as a sequence of zeroes and ones. More...
std::ostream & | regina::Bitmask1< T >::operator (std::ostream &out, const Bitmask1< T > &mask)
std::ostream & | regina::Bitmask2< T, U >::operator (std::ostream &out, const Bitmask2< T, U > &mask)
std::ostream & | regina::BoolSet::operator<< (std::ostream &out, const BoolSet &set)
| Writes the given boolean set to the given output stream. More...
std::ostream & | regina::Qitmask1< T >::operator (std::ostream &out, const Qitmask1< T > &mask)
std::ostream & | regina::Qitmask2< T, U >::operator (std::ostream &out, const Qitmask2< T, U > &mask)
std::ostream & | regina::Tritmask1< T >::operator<< (std::ostream &out, const Tritmask1< T > &mask)
| Writes the given tritmask to the given output stream as a sequence of digits (0, 1 and/or 2). More...
std::ostream & | regina::Tritmask2< T, U >::operator<< (std::ostream &out, const Tritmask2< T, U > &mask)
| Writes the given tritmask to the given output stream as a sequence of digits (0, 1 and/or 2). More...

## Detailed Description

Miscellaneous helper classes and functions

## Typedef Documentation

## argument_type

template<class T >

typedef T* regina::FuncDelete< T >::argument_type

The argument type for this unary function.

## BitmaskLen16

typedef Bitmask1<unsigned int> regina::BitmaskLen16

A convenience typedef that gives a small and extremely fast bitmask class capable of holding at least 16 true-or-false bits.

This bitmask class is guaranteed to be an instantiation of the template class Bitmask1.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## BitmaskLen32

typedef InternalBitmaskLen32 ::Type regina::BitmaskLen32

A convenience typedef that gives a small and extremely fast bitmask class capable of holding at least 32 true-or-false bits.

This bitmask class is guaranteed to be an instantiation of the template class Bitmask1.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## BitmaskLen64

typedef InternalBitmaskLen64 ::Type regina::BitmaskLen64

A convenience typedef that gives a small and extremely fast bitmask class capable of holding at least 64 true-or-false bits.

This bitmask class is guaranteed to be an instantiation of either the template class Bitmask1 or the template class Bitmask2.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## BitmaskLen8

typedef Bitmask1<unsigned char> regina::BitmaskLen8

A convenience typedef that gives a small and extremely fast bitmask class capable of holding at least 8 true-or-false bits.

This bitmask class is guaranteed to be an instantiation of the template class Bitmask1.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## element_type

template<class T >

typedef T regina::SafePtr< T >::element_type

The pointee type.

This typedef is used by the boost infrastructure.

## Enum

template<typename T>

typedef T regina::Flags< T >::Enum

The underlying enumeration type.

## InitType [1/2]

template<typename T>

typedef T* regina::StoreManagedPtr< T >::InitType

The type by which new values for the underlying property are passed.

## InitType [2/2]

template<typename T, template< typename Stored > class Storage = StoreValue>

typedef Storage<T>::InitType regina::Property< T, Storage >::InitType

The type by which new values for the underlying property are passed.

## iterator

template<typename T>

typedef std::list<const T*>::const_iterator regina::ListOnCall< T >::iterator

An iterator over this list.

This operates as a forward iterator in a manner consistent with the standard C++ library. It does not allow either the list or its individual objects to be changed.

## NBoolSet

typedef BoolSet regina::NBoolSet

Deprecated typedef for backward compatibility.

This typedef will be removed in a future release of Regina.

Deprecated:
  The class NBoolSet has now been renamed to BoolSet.

## QitmaskLen16

typedef Qitmask1<unsigned int> regina::QitmaskLen16

A convenience typedef that gives a small and extremely fast qitmask class capable of holding at least 16 true-or-false bits.

This qitmask class is guaranteed to be an instantiation of the template class Qitmask1.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## QitmaskLen32

typedef InternalQitmaskLen32 ::Type regina::QitmaskLen32

A convenience typedef that gives a small and extremely fast qitmask class capable of holding at least 32 true-or-false bits.

This qitmask class is guaranteed to be an instantiation of the template class Qitmask1.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## QitmaskLen64

typedef InternalQitmaskLen64 ::Type regina::QitmaskLen64

A convenience typedef that gives a small and extremely fast qitmask class capable of holding at least 64 true-or-false bits.

This qitmask class is guaranteed to be an instantiation of either the template class Qitmask1 or the template class Qitmask2.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## QitmaskLen8

typedef Qitmask1<unsigned char> regina::QitmaskLen8

A convenience typedef that gives a small and extremely fast qitmask class capable of holding at least 8 true-or-false bits.

This qitmask class is guaranteed to be an instantiation of the template class Qitmask1.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## QueryType

template<typename T, template< typename Stored > class Storage = StoreValue>

typedef Storage<T>::QueryType regina::Property< T, Storage >::QueryType

The type by which the property value is returned to the user.

## result_type [1/6]

template<class T >

typedef T* regina::FuncNew< T >::result_type

The return type for this generator.

## result_type [2/6]

template<class T >

typedef T* regina::FuncNewCopyPtr< T >::result_type

The return type for this unary function.

## result_type [3/6]

template<typename T , typename Comp = std::less<T>>

typedef bool regina::LessDeref< T, Comp >::result_type

The result type for this binary comparison function.

## result_type [4/6]

template<class T >

typedef T* regina::FuncNewCopyRef< T >::result_type

The return type for this unary function.

## result_type [5/6]

template<class T >

typedef T* regina::FuncNewClonePtr< T >::result_type

The return type for this unary function.

## result_type [6/6]

template<class T >

typedef void regina::FuncDelete< T >::result_type

The return type for this unary function.

## SafePointeeType

template<class T>

typedef T regina::SafePointeeBase< T >::SafePointeeType

The type of object being pointed to.

## TritmaskLen16

typedef Tritmask1<unsigned int> regina::TritmaskLen16

A convenience typedef that gives a small and extremely fast tritmask class capable of holding at least 16 true-or-false bits.

This tritmask class is guaranteed to be an instantiation of the template class Tritmask1.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## TritmaskLen32

typedef InternalTritmaskLen32 ::Type regina::TritmaskLen32

A convenience typedef that gives a small and extremely fast tritmask class capable of holding at least 32 true-or-false bits.

This tritmask class is guaranteed to be an instantiation of the template class Tritmask1.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## TritmaskLen64

typedef InternalTritmaskLen64 ::Type regina::TritmaskLen64

A convenience typedef that gives a small and extremely fast tritmask class capable of holding at least 64 true-or-false bits.

This tritmask class is guaranteed to be an instantiation of either the template class Tritmask1 or the template class Tritmask2.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## TritmaskLen8

typedef Tritmask1<unsigned char> regina::TritmaskLen8

A convenience typedef that gives a small and extremely fast tritmask class capable of holding at least 8 true-or-false bits.

This tritmask class is guaranteed to be an instantiation of the template class Tritmask1.

The particular instantiation is subject to change between different platforms, different compilers and/or different versions of Regina.

Python:\n Not present.

## Enumeration Type Documentation

## anonymous enum

template<typename T , unsigned size = sizeof(T)>

anonymous enum

Enumerator
specialised | Indicates whether this class is a template specialisation of BitManipulator with extra optimisations. This compile-time constant is set to 0 for the generic implementation of BitManipulator, and 1 for all specialisations.

## Function Documentation

## atMostOneBit() [1/3]

bool regina::Bitmask::atMostOneBit | ( |  | ) | const

inline

Determines whether at most one bit is set to `true` in this bitmask.

If this bitmask is entirely `false` or if only one bit is set to `true`, then this routine will return `true`. Otherwise this routine will return `false`.

Returns
  `true` if and only if at most one bit is set to `true`.

## atMostOneBit() [2/3]

template<typename T >

bool regina::Bitmask1< T >::atMostOneBit | ( |  | ) | const

inline

Determines whether at most one bit is set to `true` in this bitmask.

If this bitmask is entirely `false` or if only one bit is set to `true`, then this routine will return `true`. Otherwise this routine will return `false`.

Returns
  `true` if and only if at most one bit is set to `true`.

## atMostOneBit() [3/3]

template<typename T , typename U = T>

bool regina::Bitmask2< T, U >::atMostOneBit | ( |  | ) | const

inline

Determines whether at most one bit is set to `true` in this bitmask.

If this bitmask is entirely `false` or if only one bit is set to `true`, then this routine will return `true`. Otherwise this routine will return `false`.

Returns
  `true` if and only if at most one bit is set to `true`.

## base64Decode() [1/2]

bool regina::base64Decode | ( | const char * | in,
|  | size_t | inlen,
|  | char ** | out,
|  | size_t * | outlen
| ) |  |

Decodes the given sequence of base64 characters, and passes back a newly allocated array containing the results.

The out pointer will be set to this new array, and outlen will be set to the number of raw bytes in this output array. This array will be allocated using `new`[], and the caller is responsible for destroying it using `delete`[].

The given base64 sequence should not contain any unexpected characters; even whitespace will cause the decoding procedure to abort.

The length of the output buffer is passed as the argument outlen. If an unexpected or invalid character is found or the output buffer is exhausted, this routine will return `false`, set out to `null`, and leave outlen undefined. Otherwise (on success) it will return `true` and set outlen to the total number of output bytes.

If the user is not interested in the length of the output array, a null pointer may be passed in the outlen argument. Note however that the output array is not terminated in any special way.

Python:\n Not present.

Parameters

  in | the input sequence of base64 characters; this does not need to be terminated in any special way.
  inlen | the length of the input sequence.
  out | the address of a pointer which will be set to the output array of raw bytes (or which will be set to `null` on failure).
  outlen | the address of an integer which will be set to the length of the output array (or which will be left undefined on failure).

Returns
  `true` if decoding was successful, or `false` if an unexpected input character was found or some other error occurred.

Author
  This routine is based on the Base64 project at base64.sourceforge.net. The original was written by Bob Trower, and is licensed under the MIT license. See the base64.h notes for details.

## base64Decode() [2/2]

bool regina::base64Decode | ( | const char * | in,
|  | size_t | inlen,
|  | char * | out,
|  | size_t * | outlen
| ) |  |

Decodes the given sequence of base64 characters, and writes the resulting raw bytes into a preallocated output buffer.

The given base64 sequence should not contain any unexpected characters; even whitespace will cause the decoding procedure to abort.

The length of the output buffer is passed as the argument outlen. If an unexpected or invalid character is found, or the output buffer is exhausted, this routine will write as many output bytes as it can and then return `false`. Otherwise (on success) it will return `true`. Either way, it will reset outlen to the total number of bytes that were written.

The total number of output bytes is important to know, since the output array is not terminated in any special way.

Python:\n Not present.

Parameters

  in | the input sequence of base64 characters; this does not need to be terminated in any special way.
  inlen | the length of the input sequence.
  out | the output buffer into which the resulting raw bytes will be written.
  outlen | must contain the length of the output buffer on entry, and on exit contains the number of output bytes that were successfully written.

Returns
  `true` if decoding was successful, or `false` if the output buffer was exhausted or an unexpected input character was found.

Author
  This routine is based on the Base64 project at base64.sourceforge.net. The original was written by Bob Trower, and is licensed under the MIT license. See the base64.h notes for details.

## base64Encode() [1/2]

size_t regina::base64Encode | ( | const char * | in,
|  | size_t | inlen,
|  | char ** | out
| ) |  |

Encodes the given sequence of raw bytes in base64, and passes back a newly allocated array containing the results.

The out pointer will be set to this new array, which will be null-terminated. This array will be allocated using `new`[], and the caller is responsible for destroying it using `delete`[].

If the output array is too large (in particular, the expected size will overflow a `size_t`), the out pointer will be set to `null`.

Python:\n Not present.

Parameters

  in | the sequence of input bytes; this does not need to be terminated in any special way.
  inlen | the length of the input sequence.
  out | the address of a pointer which will be set to the output array of base64 characters.

Returns
  the length of the output array, not counting the terminating null.

Author
  This routine is based on the Base64 project at base64.sourceforge.net. The original was written by Bob Trower, and is licensed under the MIT license. See the base64.h notes for details.

## base64Encode() [2/2]

void regina::base64Encode | ( | const char * | in,
|  | size_t | inlen,
|  | char * | out,
|  | size_t | outlen
| ) |  |

Encodes the given sequence of raw bytes in base64, and writes the results into a preallocated output buffer.

The length of the output buffer is passed as the argument outlen. If the number of base64 characters required is less than outlen, a terminating `null` will be written to the end of the output sequence. If the number of base64 characters is outlen or greater, this routine will output as many base64 characters as possible, up to a maximum of outlen.

The routine base64Length() can be used to precalculate precisely how many output characters will be required.

Python:\n Not present.

Parameters

  in | the sequence of input bytes; this does not need to be terminated in any special way.
  inlen | the length of the input sequence.
  out | the output buffer into which the resulting base64 characters will be written.
  outlen | the length of the output buffer.

Author
  This routine is based on the Base64 project at base64.sourceforge.net. The original was written by Bob Trower, and is licensed under the MIT license. See the base64.h notes for details.

## base64Length()

size_t regina::base64Length | ( | size_t | bytes | ) |

inline

Returns the number of base64 characters required to encode the given number of bytes.

This is the number of characters used (excluding the null terminator) by the routine base64Encode(const char*, size_t, char**).

Python:\n Not present.

Parameters

  bytes | the number of raw input bytes.

Returns
  the corresponding number of base64 printable output characters.

## basicTokenise()

template<class OutputIterator >

unsigned regina::basicTokenise | ( | OutputIterator | results,
|  | const std::string & | str
| ) |  |

Decomposes the given string into tokens.

This is an extremely simple tokeniser; tokens are defined to be separated by whitespace.

Warning
  This routine treats all strings as plain ASCII. In particular, characters are examined one at a time, and the C routine isspace() is used to identify whitespace. Use it on strings with international characters at your own peril.

Python:\n Not present.

Parameters

  results | the output iterator to which the resulting tokens will be written; this must accept objects of type `const std::string&`.
  str | the string to decompose.

Returns
  the number of tokens found.

## begin()

template<typename T>

iterator regina::ListOnCall< T >::begin | ( |  | ) | const

inline

Returns an iterator pointing to the first item in this list.

If the list has not yet been filled with items, this will take place now. Thus the first call to begin() will be expensive, but subsequent calls will be extremely cheap.

Returns
  an iterator pointing to the first item.

## Bitmask() [1/3]

regina::Bitmask::Bitmask | ( |  | ) |

inline

Creates a new invalid bitmask.

You must call the one-argument reset(size_t) or use the assignment operator to give the bitmask a length before it can be used.

Use of this default constructor is discouraged. The only reason it exists is to support arrays and containers of bitmasks, where the bitmasks must be created in bulk and then individually assigned lengths.

Warning
  No other routines can be used with this bitmask until it has been assigned a length via reset(size_t) or the assignment operator. As the single exception, the class destructor is safe to use even if a bitmask has never been initialised.

## Bitmask() [2/3]

regina::Bitmask::Bitmask | ( | const Bitmask & | cloneMe | ) |

inline

Creates a clone of the given bitmask.

It is fine if the given bitmask is invalid (but in this case, the new bitmask will be invalid also). Invalid bitmasks must be assigned a length using reset(size_t) or the assignment operator.

Parameters

  cloneMe | the bitmask to clone.

## Bitmask() [3/3]

regina::Bitmask::Bitmask | ( | size_t | length | ) |

inline

Creates a new bitmask of the given length with all bits set to `false`.

Parameters

  length | the number of bits stored in this bitmask; this must be at least one.

## Bitmask1() [1/3]

template<typename T >

regina::Bitmask1< T >::Bitmask1 | ( |  | ) |

inline

Creates a new bitmask with all bits set to `false`.

## Bitmask1() [2/3]

template<typename T >

regina::Bitmask1< T >::Bitmask1 | ( | const Bitmask1< T > & | cloneMe | ) |

inline

Creates a clone of the given bitmask.

Parameters

  cloneMe | the bitmask to clone.

## Bitmask1() [3/3]

template<typename T >

regina::Bitmask1< T >::Bitmask1 | ( | size_t |  | ) |

inline

Creates a new bitmask with all bits set to `false`.

The integer argument is merely for compatibility with the Bitmask constructor, and will be ignored.

Warning
  This is not a constructor that initialises the bitmask to a given pattern.

## Bitmask2() [1/3]

template<typename T , typename U = T>

regina::Bitmask2< T, U >::Bitmask2 | ( |  | ) |

inline

Creates a new bitmask with all bits set to `false`.

## Bitmask2() [2/3]

template<typename T , typename U = T>

regina::Bitmask2< T, U >::Bitmask2 | ( | const Bitmask2< T, U > & | cloneMe | ) |

inline

Creates a clone of the given bitmask.

Parameters

  cloneMe | the bitmask to clone.

## Bitmask2() [3/3]

template<typename T , typename U = T>

regina::Bitmask2< T, U >::Bitmask2 | ( | size_t |  | ) |

inline

Creates a new bitmask with all bits set to `false`.

The integer argument is merely for compatibility with the Bitmask constructor, and will be ignored.

Warning
  This is not a constructor that initialises the bitmask to a given pattern.

## bits() [1/4]

size_t regina::Bitmask::bits | ( |  | ) | const

inline

Returns the number of bits currently set to `true` in this bitmask.

Returns
  the number of `true` bits.

## bits() [2/4]

template<typename T >

size_t regina::Bitmask1< T >::bits | ( |  | ) | const

inline

Returns the number of bits currently set to `true` in this bitmask.

Returns
  the number of `true` bits.

## bits() [3/4]

template<typename T , typename U = T>

size_t regina::Bitmask2< T, U >::bits | ( |  | ) | const

inline

Returns the number of bits currently set to `true` in this bitmask.

Returns
  the number of `true` bits.

## bits() [4/4]

template<typename T , unsigned size = sizeof(T)>

static int regina::BitManipulator< T, size >::bits | ( | T | x | ) |

inline static

Returns the number of bits that are set in the given integer.

Specifically, this routine returns the number of bits set to 1 from amongst the lowest size bytes of x.

Parameters

  x | the integer of type T to examine.

Returns
  the number of bits that are set.

## BoolSet() [1/4]

regina::BoolSet::BoolSet | ( |  | ) |

inline

Creates a new empty set.

## BoolSet() [2/4]

regina::BoolSet::BoolSet | ( | bool | insertTrue,
|  | bool | insertFalse
| ) |  |

inline

Creates a set specifying whether `true` and/or `false` should be a member.

Parameters

  insertTrue | should the new set include the element `true`?
  insertFalse | should the new set include the element `false`?

## BoolSet() [3/4]

regina::BoolSet::BoolSet | ( | bool | member | ) |

inline

Creates a set containing a single member as given.

Parameters

  member | the single element to include in this set.

## BoolSet() [4/4]

regina::BoolSet::BoolSet | ( | const BoolSet & | cloneMe | ) |

inline

Creates a set equal to the given set.

Parameters

  cloneMe | the set upon which we will base the new set.

## byteCode()

unsigned char regina::BoolSet::byteCode | ( |  | ) | const

inline

Returns the byte code representing this boolean set.

The byte code is sufficient to reconstruct the set and is thus a useful means for passing boolean sets to and from the engine.

The lowest order bit of the byte code is 1 if and only if `true` is in the set. The next lowest order bit is 1 if and only if `false` is in the set. All other bits are 0. Thus sets BoolSet::sNone, BoolSet::sTrue, BoolSet::sFalse and BoolSet::sBoth have byte codes 0, 1, 2 and 3 respectively.

Returns
  the byte code representing this set.

## characters()

void regina::xml::XMLParserCallback::characters | ( | const std::string & | s | ) |

inline virtual

Called when characters are encountered.

Parameters

  s | the characters encountered.

Reimplemented in regina::XMLCallback.

## clear() [1/6]

template<typename T>

void regina::StoreValue< T >::clear | ( |  | ) |

inline

Cleans up any currently held value before the property value is changed or cleared.

This implementation does nothing.

## clear() [2/6]

template<typename T >

void regina::StoreConstPtr< T >::clear | ( |  | ) |

inline

Cleans up any currently held value before the property value is changed or cleared.

This implementation resets the held pointer to 0.

## clear() [3/6]

template<typename T>

void regina::StoreManagedPtr< T >::clear | ( |  | ) |

inline

Cleans up any currently held value before the property value is changed or cleared.

This implementation resets the held pointer to 0 and destroys the previously held value if any exists.

## clear() [4/6]

template<typename T, template< typename Stored > class Storage = StoreValue>

void regina::Property< T, Storage >::clear | ( |  | ) |

inline

Marks this property as unknown.

## clear() [5/6]

template<typename T>

void regina::Flags< T >::clear | ( | const Flags< T > & | rhs | ) |

inline

Clears all bits from this set that appear in the given set.

Parameters

  rhs | identifies the bits to clear from this set.

## clear() [6/6]

template<typename T>

void regina::Flags< T >::clear | ( | T | rhs | ) |

inline

Clears all bits from this set that appear in the given flag.

Parameters

  rhs | the flag to clear from this set.

## clonePtr() [1/2]

template<typename T >

T* regina::clonePtr | ( | const std::unique_ptr< T > & | cloneMe | ) |

inline

A simple routine for cloning an object if and only if it exists.

If the given pointer is non-null, this routine returns a new clone of the object, created using the copy constructor for type T. Otherwise this routine simply returns a null pointer.

Note that, even though this routine takes a std::unique_ptr, it returns a raw pointer. The caller of this routine is responsible for deleting the new clone when it is no longer required.

This routine can be useful when implementing copy constructors for classes that only initialise internal data members on demand.

Python:\n Not present.

Parameters

  cloneMe | a pointer to the object to clone; this may be null.

Returns
  a newly allocated copy of the given object, or the null pointer if cloneMe is null.

## clonePtr() [2/2]

template<typename T >

T* regina::clonePtr | ( | T * | cloneMe | ) |

inline

A simple routine for cloning an object if and only if it exists.

If the given pointer is non-null, this routine returns a new clone of the object, created using the copy constructor for type T. Otherwise this routine simply returns a null pointer.

The caller of this routine is responsible for deleting the new clone when it is no longer required.

This routine can be useful when implementing copy constructors for classes that only initialise internal data members on demand.

Python:\n Not present.

Parameters

  cloneMe | a pointer to the object to clone; this may be null.

Returns
  a newly allocated copy of the given object, or the null pointer if cloneMe is null.

## close()

IConvStreamBuffer* regina::i18n::IConvStreamBuffer::close | ( |  | ) |
throw | ( |
| ) |  |

Closes this stream buffer.

Returns
  this stream buffer on success, or 0 on error.

## codeset()

static const char* regina::i18n::Locale::codeset | ( |  | ) |

static

Returns the character encoding used in the current locale.

This is a plain string, such as "UTF-8" or "ISO-8859-1".

Returns
  the character encoding for the current locale.

## comment()

void regina::xml::XMLParserCallback::comment | ( | const std::string & | s | ) |

inline virtual

Called when a comment is encountered.

Parameters

  s | the comment string.

## contains()

bool regina::BoolSet::contains | ( | bool | value | ) | const

inline

Determines if the given boolean is a member of this set.

Parameters

  value | the boolean to search for in this set.

Returns
  `true` if and only if the given boolean is a member of this set.

## containsIntn() [1/3]

bool regina::Bitmask::containsIntn | ( | const Bitmask & | x,
|  | const Bitmask & | y
| ) |  | const

inline

Determines whether this bitmask contains the intersection of the two given bitmasks.

For this routine to return `true`, every bit that is set in both x and y must be set in this bitmask also.

Precondition
  Both x and y are the same length as this bitmask.

Parameters

  x | the first bitmask used to form the intersection.
  y | the first bitmask used to form the intersection.

Returns
  `true` if and only if this bitmask entirely contains the intersection of x and y.

## containsIntn() [2/3]

template<typename T >

bool regina::Bitmask1< T >::containsIntn | ( | const Bitmask1< T > & | x,
|  | const Bitmask1< T > & | y
| ) |  | const

inline

Determines whether this bitmask contains the intersection of the two given bitmasks.

For this routine to return `true`, every bit that is set in both x and y must be set in this bitmask also.

Parameters

  x | the first bitmask used to form the intersection.
  y | the first bitmask used to form the intersection.

Returns
  `true` if and only if this bitmask entirely contains the intersection of x and y.

## containsIntn() [3/3]

template<typename T , typename U = T>

bool regina::Bitmask2< T, U >::containsIntn | ( | const Bitmask2< T, U > & | x,
|  | const Bitmask2< T, U > & | y
| ) |  | const

inline

Determines whether this bitmask contains the intersection of the two given bitmasks.

For this routine to return `true`, every bit that is set in both x and y must be set in this bitmask also.

Parameters

  x | the first bitmask used to form the intersection.
  y | the first bitmask used to form the intersection.

Returns
  `true` if and only if this bitmask entirely contains the intersection of x and y.

## duplicate()

char* regina::duplicate | ( | const std::string & | str | ) |

Creates a new C string that is a duplicate of the given C++ string.

The deallocation of the new C string is the responsibility of the caller of this routine.

Python:\n Not present.

Parameters

  str | the C++ string to duplicate.

Returns
  the new duplicate C string.

## empty() [1/5]

void regina::BoolSet::empty | ( |  | ) |

inline

Removes all elements from this set.

## empty() [2/5]

template<typename T >

bool regina::Tritmask1< T >::empty | ( |  | ) | const

inline

Determines whether this tritmask contains all zeroes.

Returns
  `true` if every trit is zero, or `false` otherwise.

## empty() [3/5]

template<typename T >

bool regina::Qitmask1< T >::empty | ( |  | ) | const

inline

Determines whether this qitmask contains all zeroes.

Returns
  `true` if every qit is zero, or `false` otherwise.

## empty() [4/5]

template<typename T , typename U = T>

bool regina::Tritmask2< T, U >::empty | ( |  | ) | const

inline

Determines whether this tritmask contains all zeroes.

Returns
  `true` if every trit is zero, or `false` otherwise.

## empty() [5/5]

template<typename T , typename U = T>

bool regina::Qitmask2< T, U >::empty | ( |  | ) | const

inline

Determines whether this qitmask contains all zeroes.

Returns
  `true` if every qit is zero, or `false` otherwise.

## end()

template<typename T>

iterator regina::ListOnCall< T >::end | ( |  | ) | const

inline

Returns an iterator pointing past the end of this list (i.e., just after the last item).

Precondition
  The begin() routine has been called at least once (otherwise the list will not yet have been filled).

Returns
  a past-the-end iterator.

## end_document()

void regina::xml::XMLParserCallback::end_document | ( |  | ) |

inline virtual

Called when the document is finalised.

Reimplemented in regina::XMLCallback.

## end_element()

void regina::xml::XMLParserCallback::end_element | ( | const std::string & | n | ) |

inline virtual

Called when an element's closing tag is encountered.

This is called immediately after start_element() if the opening tag is in `<tag/>` format.

Parameters

  n | the name of the tag.

Reimplemented in regina::XMLCallback.

## ensureOne() [1/3]

template<typename T>

void regina::Flags< T >::ensureOne | ( | T | default_,
|  | T | other
| ) |  |

inline

Adjust this set so that exactly one and only one of the two given flags are included.

If neither flag is present or both flags are present, this set will be adjusted so that default_ is present and other is not.

Precondition
  Both default_ and other are each single-bit flags.

Python:\n Not present, even for flag types that are
  exposed to Python.

Parameters

  default_ | the flag that will be set if any adjustments need to be made.
  other | the flag that will be cleared if any adjustments need to be made.

## ensureOne() [2/3]

template<typename T>

void regina::Flags< T >::ensureOne | ( | T | default_,
|  | T | second,
|  | T | last
| ) |  |

inline

Adjust this set so that exactly one and only one of the three given flags are included.

If neither flag is present, then default_ will be used. If multiple flags are present, then the flag that appears earlier in the argument list for this routine will be used.

Precondition
  Each of the given flags is single-bit.

Python:\n Not present, even for flag types that are
  exposed to Python.

Parameters

  default_ | the highest-priority flag.
  second | the second-highest-priority flag.
  last | the lowest-priority flag.

## ensureOne() [3/3]

template<typename T>

void regina::Flags< T >::ensureOne | ( | T | default_,
|  | T | second,
|  | T | third,
|  | T | last
| ) |  |

inline

Adjust this set so that exactly one and only one of the four given flags are included.

If neither flag is present, then default_ will be used. If multiple flags are present, then the flag that appears earlier in the argument list for this routine will be used.

Precondition
  Each of the given flags is single-bit.

Python:\n Not present, even for flag types that are
  exposed to Python.

Parameters

  default_ | the highest-priority flag.
  second | the second-highest-priority flag.
  third | the third-highest-priority flag.
  last | the lowest-priority flag.

## erase() [1/2]

template<typename T>

std::vector<T*>::iterator regina::MarkedVector< T >::erase | ( | typename std::vector< T * >::iterator | first,
|  | typename std::vector< T * >::iterator | last
| ) |  |

inline

Erases all items in the given range in this vector.

The items will not be destroyed, and the (now irrelevant) indices stored inside them will not be modified.

Precondition
  The given iterators describe a valid range in this vector.

Parameters

  first | an iterator pointing to the first element to erase.
  last | an iterator pointing just beyond the last element to erase.

Returns
  an iterator pointing to the element immediately after the elements that were erased.

## erase() [2/2]

template<typename T>

std::vector<T*>::iterator regina::MarkedVector< T >::erase | ( | typename std::vector< T * >::iterator | pos | ) |

inline

Erases the item at the given position in this vector.

The item will not be destroyed, and the (now irrelevant) index stored inside it will not be modified.

Precondition
  The given iterator points to an element of this vector.

Parameters

  pos | an iterator pointing to the element to erase.

Returns
  an iterator pointing to the element immediately after the element that was erased.

## error()

void regina::xml::XMLParserCallback::error | ( | const std::string & | s | ) |

inline virtual

Called when a parser error occurs.

Parameters

  s | the error message.

Reimplemented in regina::XMLCallback.

## expire()

template<class T >

void regina::detail::SafeRemnant< T >::expire | ( |  | ) |

inline

Expire the remnant so that it can no longer be dereferenced.

Any subsequent call to get() will return 0.

This routine is called by the pointee's destructor.

## fatal_error()

void regina::xml::XMLParserCallback::fatal_error | ( | const std::string & | s | ) |

inline virtual

Called when a parser fatal error occurs.

Parameters

  s | the error message.

Reimplemented in regina::XMLCallback.

## fill()

void regina::BoolSet::fill | ( |  | ) |

inline

Places both `true` and `false` into this set if they are not already present.

## finish()

void regina::xml::XMLParser::finish | ( |  | ) |

inline

Signals that there are no more XML chunks to parse.

## firstBit() [1/4]

long regina::Bitmask::firstBit | ( |  | ) | const

inline

Returns the index of the first `true` bit in this bitmask, or -1 if there are no `true` bits.

Returns
  the index of the first `true` bit.

## firstBit() [2/4]

template<typename T >

long regina::Bitmask1< T >::firstBit | ( |  | ) | const

inline

Returns the index of the first `true` bit in this bitmask, or -1 if there are no `true` bits.

Returns
  the index of the first `true` bit.

## firstBit() [3/4]

template<typename T , typename U = T>

long regina::Bitmask2< T, U >::firstBit | ( |  | ) | const

inline

Returns the index of the first `true` bit in this bitmask, or -1 if there are no `true` bits.

Returns
  the index of the first `true` bit.

## firstBit() [4/4]

template<typename T , unsigned size = sizeof(T)>

static int regina::GenericBitManipulator< T, size >::firstBit | ( | T | x | ) |

inline static

Returns the index of the first `true` bit in the given integer, or -1 if the given integer is zero.

Bits are indexed from 0 upwards, starting at the least significant bit.

Parameters

  x | the integer of type T to examine.

Returns
  the position of the first `true` bit, or -1 if there are no `true` bits.

## Flags() [1/3]

template<typename T>

regina::Flags< T >::Flags | ( |  | ) |

inline

Creates an empty flag set, with no flags set at all.

## Flags() [2/3]

template<typename T>

regina::Flags< T >::Flags | ( | const Flags< T > & | init | ) |

inline

Creates a clone of the given flag set.

Parameters

  init | the flag set to clone.

## Flags() [3/3]

template<typename T>

regina::Flags< T >::Flags | ( | T | init | ) |

inline

Creates a flag set initialised to the given value.

Parameters

  init | the initial value of this flag set.

## flip() [1/3]

void regina::Bitmask::flip | ( |  | ) |

inline

Negates every bit in this bitmask.

All `true` bits will be set to `false` and vice versa.

Warning
  Because this class may increase the bitmask length (rounding up to the next unit of storage), flip() may set additional `true` bits in the "dead space" between the intended length and the actual length. This may cause unexpected results for routines such as subset testing, bit counting and so on. Be careful!

## flip() [2/3]

template<typename T >

void regina::Bitmask1< T >::flip | ( |  | ) |

inline

Negates every bit in this bitmask.

All `true` bits will be set to `false` and vice versa.

Unlike the more generic Bitmask, this optimised bitmask class does not store a length. This means that all 8 * sizeof(T) possible bits will be negated.

## flip() [3/3]

template<typename T , typename U = T>

void regina::Bitmask2< T, U >::flip | ( |  | ) |

inline

Negates every bit in this bitmask.

All `true` bits will be set to `false` and vice versa.

Unlike the more generic Bitmask, this optimised bitmask class does not store a length. This means that all 8 * sizeof(T) + 8 * sizeof(U) possible bits will be negated.

## fromByteCode()

BoolSet regina::BoolSet::fromByteCode | ( | unsigned char | code | ) |

inline static

Creates a boolean set from the given byte code.

See byteCode() for more information on byte codes.

Precondition
  code is 0, 1, 2 or 3.

Parameters

  code | the byte code from which the new set will be created.

## fromInt()

template<typename T>

static Flags<T> regina::Flags< T >::fromInt | ( | int | value | ) |

inline static

Returns the set corresponding to the given integer value.

This is suitable for file input and/or output.

Warning
  This function should not be used widely, since it effectively works around inbuilt type safety mechanisms.

Returns
  the set corresponding to the given integer value.

## get() [1/9]

template<class T >

T * regina::detail::SafeRemnant< T >::get | ( |  | ) | const

inline

Dereference this remnant.

Returns
  the pointee corresponding to this remnant, or 0 if the original pointee has since been destroyed.

## get() [2/9]

template<class T >

T * regina::SafePtr< T >::get | ( |  | ) | const

inline

Returns a raw pointer to the pointee, or `null` if the pointee has already been destroyed.

Returns
  the pointee.

## get() [3/9]

bool regina::Bitmask::get | ( | size_t | index | ) | const

inline

Returns the value of the given bit of this bitmask.

Parameters

  index | indicates which bit to query; this must be at least zero and strictly less than the length of this bitmask.

Returns
  the value of the (index)th bit.

## get() [4/9]

template<typename T >

bool regina::Bitmask1< T >::get | ( | size_t | index | ) | const

inline

Returns the value of the given bit of this bitmask.

Parameters

  index | indicates which bit to query; this must be between 0 and (8 * sizeof(T) - 1) inclusive.

Returns
  the value of the (index)th bit.

## get() [5/9]

template<typename T , typename U = T>

bool regina::Bitmask2< T, U >::get | ( | size_t | index | ) | const

inline

Returns the value of the given bit of this bitmask.

Parameters

  index | indicates which bit to query; this must be between 0 and (8 * sizeof(T) + 8 * sizeof(U) - 1) inclusive.

Returns
  the value of the (index)th bit.

## get() [6/9]

template<typename T >

char regina::Tritmask1< T >::get | ( | unsigned | index | ) | const

inline

Returns the value of the given trit in this tritmask.

Parameters

  index | indicates which trit to query; this must be between 0 and (8 * sizeof(T) - 1) inclusive.

Returns
  the value of the (index)th trit; this will be either 0, 1 or 2.

## get() [7/9]

template<typename T >

char regina::Qitmask1< T >::get | ( | unsigned | index | ) | const

inline

Returns the value of the given qit in this qitmask.

Parameters

  index | indicates which qit to query; this must be between 0 and (8 * sizeof(T) - 1) inclusive.

Returns
  the value of the (index)th qit; this will be either 0, 1, 2 or 3.

## get() [8/9]

template<typename T , typename U = T>

char regina::Tritmask2< T, U >::get | ( | unsigned | index | ) | const

inline

Returns the value of the given trit in this tritmask.

Parameters

  index | indicates which trit to query; this must be between 0 and (8 * sizeof(T) + 8 * sizeof(U) - 1) inclusive.

Returns
  the value of the (index)th trit; this will be either 0, 1 or 2.

## get() [9/9]

template<typename T , typename U = T>

char regina::Qitmask2< T, U >::get | ( | unsigned | index | ) | const

inline

Returns the value of the given qit in this qitmask.

Parameters

  index | indicates which qit to query; this must be between 0 and (8 * sizeof(T) + 8 * sizeof(U) - 1) inclusive.

Returns
  the value of the (index)th qit; this will be either 0, 1, 2 or 3.

## get_pointer()

template<class T >

T* boost::get_pointer | ( | regina::SafePtr< T > const & | ptr | ) |

inline

Extracts a raw pointer from the given safe pointer.

This is required for SafePtr to support the boost dereferencable concept.

Parameters

  ptr | a safe pointer. This may be `null`.

Returns
  the corresponding raw pointer.

## getOrCreate()

template<class T>

SafeRemnant< T > * regina::detail::SafeRemnant< T >::getOrCreate | ( | T * | object | ) |

static

Given an object deriving from SafePointeeBase, find or create the remnant corresponding to the object.

Each pointee `object` has at most one remnant. If it already exists, this routine returns it. If not, this routine creates a new one.

Parameters

  object | the object deriving from SafePointeeBase.

Returns
  the corresponding remnant.

## has() [1/2]

template<typename T>

bool regina::Flags< T >::has | ( | const Flags< T > & | rhs | ) | const

inline

Returns whether all of the flags in the given set are set.

This requires all of the bits of all of the flags in the given set to be present in this set. The test is equivalent to `(*this & rhs) == rhs`.

Parameters

  rhs | the set whose presence will be tested.

Returns
  `true` if and only if all of the bits of the given set are present in this set.

## has() [2/2]

template<typename T>

bool regina::Flags< T >::has | ( | T | flag | ) | const

inline

Returns whether the given flag is set.

This requires all of the bits of the given flag to be set. The test is equivalent to `(*this & flag) == flag`.

Parameters

  flag | the flag whose presence will be tested.

Returns
  `true` if and only if all of the bits of the given flag are set.

## has2() [1/2]

template<typename T >

bool regina::Tritmask1< T >::has2 | ( |  | ) | const

inline

Determines whether this tritmask contains at least one trit with value 2.

Returns
  `true` if at least one trit is 2, or `false` otherwise.

## has2() [2/2]

template<typename T , typename U = T>

bool regina::Tritmask2< T, U >::has2 | ( |  | ) | const

inline

Determines whether this tritmask contains at least one trit with value 2.

Returns
  `true` if at least one trit is 2, or `false` otherwise.

## has3() [1/2]

template<typename T >

bool regina::Qitmask1< T >::has3 | ( |  | ) | const

inline

Determines whether this qitmask contains at least one qit with value 3.

Returns
  `true` if at least one qit is 3, or `false` otherwise.

## has3() [2/2]

template<typename T , typename U = T>

bool regina::Qitmask2< T, U >::has3 | ( |  | ) | const

inline

Determines whether this qitmask contains at least one qit with value 3.

Returns
  `true` if at least one qit is 3, or `false` otherwise.

## hasExtraSuperset()

template<typename T >

bool regina::TrieSet< T >::hasExtraSuperset | ( | const T & | subset,
|  | const T & | exc1,
|  | const T & | exc2,
|  | unsigned long | universeSize
| ) |  | const

Performs the particular superset search required by the double description method.

This routine asks the following question: In this collection of sets, is there any superset of the argument subset other than exc1 or exc2? Here the sets exc1 and exc2 are explicitly excluded from our search. Supersets need not be proper supersets (so if an exact copy of subset is found in the tree then this will suffice).

This routine has a slow running time, which in pathological cases can grow to either `2^n` (where n is the bitmask length) or the number of sets stored in this collection, whichever is smaller. However, for "typical" searches in the context of normal surface enumeration, the running time is often significantly faster.

Precondition
  The sets exc1 and exc2 are distinct, and each is contained in this collection precisely once.

Parameters

  subset | the object of the query: we are searching this collection for a (non-strict) superset of this argument.
  exc1 | the first set in the collection to be excluded from this search.
  exc2 | the second set in the collection to be excluded from this search.
  universeSize | the number of elements in the underlying universe (and therefore the lowest possible level in the search tree). Note that this is always less than or equal to the number of bits that the underlying bitmask type T can support.

Returns
  `true` if a superset with the required properties was found, or `false` otherwise.

## hasFalse()

bool regina::BoolSet::hasFalse | ( |  | ) | const

inline

Determines if `false` is a member of this set.

Returns
  `true` if and only if `false` is a member of this set.

## hasNonZeroMatch() [1/2]

template<typename T >

bool regina::Qitmask1< T >::hasNonZeroMatch | ( | const Qitmask1< T > & | other | ) | const

inline

Determines whether there is some index at which both this and the given qitmask both have non-zero qits.

That is, there is some index i for which `get(i)` and `other.get(i)` are both non-zero.

Note that these two qits do not need to be equal; they just both need to be non-zero. Note also that this only needs to happen at one index; there may be other indices at which the qit is zero in one qitmask but not the other.

Parameters

  other | the qitmask to compare with this.

Returns
  `true` if there is some index at which this and other both have non-zero qits, or `false` otherwise.

## hasNonZeroMatch() [2/2]

template<typename T , typename U = T>

bool regina::Qitmask2< T, U >::hasNonZeroMatch | ( | const Qitmask2< T, U > & | other | ) | const

inline

Determines whether there is some index at which both this and the given qitmask both have non-zero qits.

That is, there is some index i for which `get(i)` and `other.get(i)` are both non-zero.

Note that these two qits do not need to be equal; they just both need to be non-zero. Note also that this only needs to happen at one index; there may be other indices at which the qit is zero in one qitmask but not the other.

Parameters

  other | the qitmask to compare with this.

Returns
  `true` if there is some index at which this and other both have non-zero qits, or `false` otherwise.

## hasSubset()

template<typename T >

bool regina::TrieSet< T >::hasSubset | ( | const T & | superset,
|  | unsigned long | universeSize
| ) |  | const

Determines whether this collection of sets contains any subset of the argument superset.

Subsets need not be proper subsets (so if an exact copy of superset is found in the tree then this will suffice).

This routine has a slow running time, which in pathological cases can grow to either `2^n` (where n is the bitmask length) or the number of sets stored in this collection, whichever is smaller. However, for "typical" searches in the context of normal surface enumeration, the running time is often significantly faster.

Parameters

  superset | the object of the query: we are searching this collection for a (non-strict) subset of this argument.
  universeSize | the number of elements in the underlying universe (and therefore the lowest possible level in the search tree). Note that this is always less than or equal to the number of bits that the underlying bitmask type T can support.

Returns
  `true` if a subset was found, or `false` otherwise.

## hasTrue()

bool regina::BoolSet::hasTrue | ( |  | ) | const

inline

Determines if `true` is a member of this set.

Returns
  `true` if and only if `true` is a member of this set.

## IConvStream()

regina::i18n::IConvStream::IConvStream | ( | std::ostream & | dest,
|  | const char * | srcCode,
|  | const char * | destCode
| ) |  |

inline

Creates a new IConvStream; see the class notes for details.

If the given encodings are invalid, this stream will still forward data to the given output stream but no conversion will take place.

See the iconv documentation for information on what encodings are supported. For the GNU C library implementation, valid encodings can be found by running `iconv –list`.

Precondition
  The destination output stream is already open.

Parameters

  dest | the destination output stream.
  srcCode | the character encoding for data that is to be written into this IConvStream.
  destCode | the character encoding for the translated data that will subsequently be written to the destination output stream.

## IConvStreamBuffer()

regina::i18n::IConvStreamBuffer::IConvStreamBuffer | ( |  | ) |

inline

Creates a new stream buffer.

## initialise()

template<typename T>

virtual void regina::ListOnCall< T >::initialise | ( |  | ) |

protected pure virtual

Fills this list with items.

The particular set of items to use will typically depend on the particular subclass of ListOnCall that is being defined.

This routine will be run the first time that begin() is called on each list, and will not be run again.

Implemented in regina::SatBlockStarterSet.

## insert() [1/2]

template<typename T >

void regina::TrieSet< T >::insert | ( | const T & | entry | ) |

Insert the given set into this collection.

The same set may be insert into this collection multiple times (and this multiplicity will be recorded correctly).

Running time for insertion is O(n), where n is the bitmask length.

Parameters

  entry | the new set to insert.

## insert() [2/2]

template<typename T>

void regina::ListOnCall< T >::insert | ( | T * | item | ) |

inline protected

Adds the given item to the end of this list.

This routine should only ever be called from within a subclass implementation of initialise().

The given item will be owned by this list, and will be destroyed when this list is destroyed.

Parameters

  item | the new item to insert.

## insertFalse()

void regina::BoolSet::insertFalse | ( |  | ) |

inline

Inserts `false` into this set if it is not already present.

## insertTrue()

void regina::BoolSet::insertTrue | ( |  | ) |

inline

Inserts `true` into this set if it is not already present.

## intValue()

template<typename T>

int regina::Flags< T >::intValue | ( |  | ) | const

inline

Returns the integer representation of this set.

This is suitable for file input and/or output.

Warning
  This function should not be used widely, since it effectively works around inbuilt type safety mechanisms.

Returns
  the integer value of this set.

## inUnion() [1/3]

bool regina::Bitmask::inUnion | ( | const Bitmask & | x,
|  | const Bitmask & | y
| ) |  | const

inline

Determines whether this bitmask is entirely contained within the union of the two given bitmasks.

For this routine to return `true`, every bit that is set in this bitmask must also be set in either x or y.

Precondition
  Both x and y are the same length as this bitmask.

Parameters

  x | the first bitmask used to form the union.
  y | the first bitmask used to form the union.

Returns
  `true` if and only if this bitmask is entirely contained within the union of x and y.

## inUnion() [2/3]

template<typename T >

bool regina::Bitmask1< T >::inUnion | ( | const Bitmask1< T > & | x,
|  | const Bitmask1< T > & | y
| ) |  | const

inline

Determines whether this bitmask is entirely contained within the union of the two given bitmasks.

For this routine to return `true`, every bit that is set in this bitmask must also be set in either x or y.

Parameters

  x | the first bitmask used to form the union.
  y | the first bitmask used to form the union.

Returns
  `true` if and only if this bitmask is entirely contained within the union of x and y.

## inUnion() [3/3]

template<typename T , typename U = T>

bool regina::Bitmask2< T, U >::inUnion | ( | const Bitmask2< T, U > & | x,
|  | const Bitmask2< T, U > & | y
| ) |  | const

inline

Determines whether this bitmask is entirely contained within the union of the two given bitmasks.

For this routine to return `true`, every bit that is set in this bitmask must also be set in either x or y.

Parameters

  x | the first bitmask used to form the union.
  y | the first bitmask used to form the union.

Returns
  `true` if and only if this bitmask is entirely contained within the union of x and y.

## isBase64()

bool regina::isBase64 | ( | char | ch | ) |

inline

Determines whether the given character is a base64 printable character as used by the base64 routines in Regina.

The base64 printable characters are the letters (both upper-case and lower-case), digits, plus (+), and forward slash (/).

Note that the equals sign (=) is padding, and is not considered by this routine to be a base64 printable character.

Python:\n Not present.

Parameters

  ch | any character.

Returns
  `true` if the given character is one of the base64 printable characters used in Regina, or `false` if it is not.

## known()

template<typename T, template< typename Stored > class Storage = StoreValue>

bool regina::Property< T, Storage >::known | ( |  | ) | const

inline

Returns whether or not this property is currently marked as known.

Returns
  whether this property is marked as known.

## lastBit() [1/4]

long regina::Bitmask::lastBit | ( |  | ) | const

inline

Returns the index of the last `true` bit in this bitmask, or -1 if there are no `true` bits.

Returns
  the index of the last `true` bit.

## lastBit() [2/4]

template<typename T >

long regina::Bitmask1< T >::lastBit | ( |  | ) | const

inline

Returns the index of the last `true` bit in this bitmask, or -1 if there are no `true` bits.

Returns
  the index of the last `true` bit.

## lastBit() [3/4]

template<typename T , typename U = T>

long regina::Bitmask2< T, U >::lastBit | ( |  | ) | const

inline

Returns the index of the last `true` bit in this bitmask, or -1 if there are no `true` bits.

Returns
  the index of the last `true` bit.

## lastBit() [4/4]

template<typename T , unsigned size = sizeof(T)>

static int regina::GenericBitManipulator< T, size >::lastBit | ( | T | x | ) |

inline static

Returns the index of the last `true` bit in the given integer, or -1 if the given integer is zero.

Bits are indexed from 0 upwards, starting at the least significant bit.

Parameters

  x | the integer of type T to examine.

Returns
  the position of the last `true` bit, or -1 if there are no `true` bits.

## lessThan() [1/3]

bool regina::Bitmask::lessThan | ( | const Bitmask & | other | ) | const

inline

Determines whether this bitmask appears strictly before the given bitmask when bitmasks are sorted in lexicographical order.

Here the bit at index 0 is least significant, and the bit at index length-1 is most significant.

Precondition
  This and the given bitmask have the same length.

Warning
  We do not use < for this operation, since <= represents the subset operation.

Parameters

  other | the bitmask to compare against this.

Returns
  `true` if and only if this is lexicographically strictly smaller than the given bitmask.

## lessThan() [2/3]

template<typename T >

bool regina::Bitmask1< T >::lessThan | ( | const Bitmask1< T > & | other | ) | const

inline

Determines whether this bitmask appears strictly before the given bitmask when bitmasks are sorted in lexicographical order.

Here the bit at index 0 is least significant, and the bit at index length-1 is most significant.

Warning
  We do not use < for this operation, since <= represents the subset operation.

Parameters

  other | the bitmask to compare against this.

Returns
  `true` if and only if this is lexicographically strictly smaller than the given bitmask.

## lessThan() [3/3]

template<typename T , typename U = T>

bool regina::Bitmask2< T, U >::lessThan | ( | const Bitmask2< T, U > & | other | ) | const

inline

Determines whether this bitmask appears strictly before the given bitmask when bitmasks are sorted in lexicographical order.

Here the bit at index 0 is least significant, and the bit at index length-1 is most significant.

Warning
  We do not use < for this operation, since <= represents the subset operation.

Parameters

  other | the bitmask to compare against this.

Returns
  `true` if and only if this is lexicographically strictly smaller than the given bitmask.

## ListOnCall()

template<typename T>

regina::ListOnCall< T >::ListOnCall | ( |  | ) |

inline

Creates a new list structure.

The list will not be filled with items; this does not happen until the first time that begin() is called.

## Locale()

regina::i18n::Locale::Locale | ( |  | ) |

delete

Disable the default constructor, since all routines are static.

## lookup()

const std::string & regina::xml::XMLPropertyDict::lookup | ( | const std::string & | key | ) | const

inline

Return a value for the given key, or the empty string if the key does not exist in the map.

Parameters

  key | the key to look up.

Returns
  the value associated with the given key, or the empty string if the key does not exist in the map.

## markedIndex()

size_t regina::MarkedElement::markedIndex | ( |  | ) | const

inline

Returns the index at which this object is stored in an MarkedVector.

If this object does not belong to an MarkedVector, the return value is undefined.

Returns
  the index at which this object is stored.

## MarkedVector()

template<typename T>

regina::MarkedVector< T >::MarkedVector | ( |  | ) |

inline

Constructs a new empty vector.

## maxWith() [1/2]

template<typename T >

Tritmask1<T>& regina::Tritmask1< T >::maxWith | ( | const Tritmask1< T > & | rhs | ) |

inline

Sets this to the maximum of this and the given tritmask.

That is, the ith trit will be set to the maximum of the ith trit in this tritmask and the ith trit in other.

This is a "trit" version of boolean OR.

Parameters

  rhs | the tritmask to "max" with this.

Returns
  a reference to this tritmask.

## maxWith() [2/2]

template<typename T , typename U = T>

Tritmask2<T, U>& regina::Tritmask2< T, U >::maxWith | ( | const Tritmask2< T, U > & | rhs | ) |

inline

Sets this to the maximum of this and the given tritmask.

That is, the ith trit will be set to the maximum of the ith trit in this tritmask and the ith trit in other.

This is a "trit" version of boolean OR.

Parameters

  rhs | the tritmask to "max" with this.

Returns
  a reference to this tritmask.

## minWith() [1/2]

template<typename T >

Tritmask1<T>& regina::Tritmask1< T >::minWith | ( | const Tritmask1< T > & | rhs | ) |

inline

Sets this to the minimum of this and the given tritmask.

That is, the ith trit will be set to the minimum of the ith trit in this tritmask and the ith trit in other.

This is a "trit" version of boolean AND.

Parameters

  rhs | the tritmask to "min" with this.

Returns
  a reference to this tritmask.

## minWith() [2/2]

template<typename T , typename U = T>

Tritmask2<T, U>& regina::Tritmask2< T, U >::minWith | ( | const Tritmask2< T, U > & | rhs | ) |

inline

Sets this to the minimum of this and the given tritmask.

That is, the ith trit will be set to the minimum of the ith trit in this tritmask and the ith trit in other.

This is a "trit" version of boolean AND.

Parameters

  rhs | the tritmask to "min" with this.

Returns
  a reference to this tritmask.

## nonEmpty() [1/4]

template<typename T >

bool regina::Tritmask1< T >::nonEmpty | ( |  | ) | const

inline

Determines whether this tritmask contains at least one non-zero trit.

Returns
  `true` if at least one trit is non-zero, or `false` otherwise.

## nonEmpty() [2/4]

template<typename T >

bool regina::Qitmask1< T >::nonEmpty | ( |  | ) | const

inline

Determines whether this qitmask contains at least one non-zero qit.

Returns
  `true` if at least one qit is non-zero, or `false` otherwise.

## nonEmpty() [3/4]

template<typename T , typename U = T>

bool regina::Tritmask2< T, U >::nonEmpty | ( |  | ) | const

inline

Determines whether this tritmask contains at least one non-zero trit.

Returns
  `true` if at least one trit is non-zero, or `false` otherwise.

## nonEmpty() [4/4]

template<typename T , typename U = T>

bool regina::Qitmask2< T, U >::nonEmpty | ( |  | ) | const

inline

Determines whether this qitmask contains at least one non-zero qit.

Returns
  `true` if at least one qit is non-zero, or `false` otherwise.

## open()

IConvStreamBuffer* regina::i18n::IConvStreamBuffer::open | ( | std::ostream & | dest,
|  | const char * | srcCode,
|  | const char * | destCode
| ) |  |

Opens a new stream buffer that wraps around the given output stream.

If this stream buffer is already open, it will be closed and then reopened with the given parameters.

Any data that is sent to this stream buffer will be translated from srcCode to destCode and passed on to the given output stream.

If the given encodings are invalid, this stream will still forward data to the given output stream but no conversion will take place.

See the iconv documentation for information on what encodings are supported. For the GNU C library implementation, valid encodings can be found by running `iconv –list`.

Precondition
  The destination output stream is already open.

Parameters

  dest | the destination output stream.
  srcCode | the character encoding for data that is to be written into this stream buffer.
  destCode | the character encoding for the translated data that will subsequently be written to the destination output stream.

Returns
  this stream buffer on success, or 0 on error.

## operator bool()

template<class T >

regina::SafePtr< T >::operator bool | ( |  | ) | const

inline

Returns `true` if the pointee is non-null and has not yet been destroyed.

This is equivalent to testing whether get() is not `null`.

Returns
  `true` if and only if the pointee is non-null and has not yet been destroyed.

## operator!=() [1/3]

bool regina::BoolSet::operator!= | ( | const BoolSet & | other | ) | const

inline

Determines if this set is not equal to the given set.

Parameters

  other | the set to compare with this.

Returns
  `true` if and only if this and the given set are not equal.

## operator!=() [2/3]

template<typename T>

bool regina::Flags< T >::operator!= | ( | const Flags< T > & | rhs | ) | const

inline

Determines whether this set is not equal to the given flag set.

Parameters

  rhs | the flag to test this against.

Returns
  `true` if and only if this and the given flag set are not identical.

## operator!=() [3/3]

template<typename T>

bool regina::Flags< T >::operator!= | ( | T | rhs | ) | const

inline

Determines whether this set is not equal to the given flag.

Parameters

  rhs | the flag to test this against.

Returns
  `true` if and only if this and the given flag are not identical.

## operator&() [1/3]

BoolSet regina::BoolSet::operator& | ( | const BoolSet & | other | ) | const

inline

Returns the intersection of this set with the given set.

The result is a set containing precisely the elements that belong to both original sets. This set is not changed.

Parameters

  other | the set to intersect with this set.

Returns
  the intersection of this and the given set.

## operator&() [2/3]

template<typename T>

Flags<T> regina::Flags< T >::operator& | ( | const Flags< T > & | rhs | ) | const

inline

Returns the bitwise AND of this and the given flag set.

This flag set is not changed.

Parameters

  rhs | the flag set to combine with this set.

Returns
  the combination of this and the given flag set.

## operator&() [3/3]

template<typename T>

Flags<T> regina::Flags< T >::operator& | ( | T | rhs | ) | const

inline

Returns the bitwise AND of this set and the given flag.

This flag set is not changed.

Parameters

  rhs | the flag to combine with this set.

Returns
  the combination of this set and the given flag.

## operator&=() [1/6]

Bitmask & regina::Bitmask::operator&= | ( | const Bitmask & | other | ) |

inline

Sets this to the intersection of this and the given bitmask.

Every bit that is unset in other will be unset in this bitmask.

Precondition
  This and the given bitmask have the same length.

Parameters

  other | the bitmask to intersect with this.

Returns
  a reference to this bitmask.

## operator&=() [2/6]

template<typename T >

Bitmask1<T>& regina::Bitmask1< T >::operator&= | ( | const Bitmask1< T > & | other | ) |

inline

Sets this to the intersection of this and the given bitmask.

Every bit that is unset in other will be unset in this bitmask.

Parameters

  other | the bitmask to intersect with this.

Returns
  a reference to this bitmask.

## operator&=() [3/6]

template<typename T , typename U = T>

Bitmask2<T, U>& regina::Bitmask2< T, U >::operator&= | ( | const Bitmask2< T, U > & | other | ) |

inline

Sets this to the intersection of this and the given bitmask.

Every bit that is unset in other will be unset in this bitmask.

Parameters

  other | the bitmask to intersect with this.

Returns
  a reference to this bitmask.

## operator&=() [4/6]

BoolSet & regina::BoolSet::operator&= | ( | const BoolSet & | other | ) |

inline

Sets this set to be the intersection of this and the given set.

The result is a set containing precisely the elements that belong to both original sets. Note that this set will be modified.

Parameters

  other | the set to intersect with this set.

Returns
  a reference to this set.

## operator&=() [5/6]

template<typename T>

Flags<T>& regina::Flags< T >::operator&= | ( | const Flags< T > & | rhs | ) |

inline

Changes this flag set by taking a bitwise AND with the given flag set.

Parameters

  rhs | the flag set to combine with this set.

Returns
  a reference to this flag set.

## operator&=() [6/6]

template<typename T>

Flags<T>& regina::Flags< T >::operator&= | ( | T | rhs | ) |

inline

Changes this flag set by taking a bitwise AND with the given flag.

Parameters

  rhs | the flag to combine with this set.

Returns
  a reference to this flag set.

## operator()() [1/7]

template<class T >

T* regina::FuncNew< T >::operator() | ( |  | ) | const

inline

Creates a new object using the default constructor.

Returns
  the newly created object.

## operator()() [2/7]

template<typename T>

const std::vector<T*>& regina::MarkedVector< T >::operator() | ( |  | ) | const

inline

Casts this vector to a const std::vector, thus providing access to the entire const functionality of std::vector.

Returns
  a reference to this vector, cast as a const std::vector.

## operator()() [3/7]

template<class T >

T* regina::FuncNewCopyRef< T >::operator() | ( | const T & | obj | ) | const

inline

Creates a new object using the copy constructor.

Parameters

  obj | the object whose data should be passed to the copy constructor.

Returns
  the newly created object.

## operator()() [4/7]

template<class T >

T* regina::FuncNewCopyPtr< T >::operator() | ( | const T * | ptr | ) | const

inline

Creates a new object using the copy constructor.

Parameters

  ptr | the pointer whose data should (after dereferencing) be passed to the copy constructor.

Returns
  the newly created object.

## operator()() [5/7]

template<class T >

T* regina::FuncNewClonePtr< T >::operator() | ( | const T * | ptr | ) | const

inline

Creates a new object using the `clone()` method.

Parameters

  ptr | the pointer whose corresponding object should be cloned.

Returns
  the newly created clone.

## operator()() [6/7]

template<typename T , typename Comp = std::less<T>>

bool regina::LessDeref< T, Comp >::operator() | ( | const T * | ptr1,
|  | const T * | ptr2
| ) |  | const

inline

Compares the objects to which the given pointers are pointing.

The two pointers are dereferenced, and then a function of type Comp (the second template argument) is used to compare the dereferenced objects.

Parameters

  ptr1 | a pointer to the first object under examination.
  ptr2 | a pointer to the second object under examination.

Returns
  `true` if the first dereferenced object is less than the second, or `false` otherwise.

## operator()() [7/7]

template<class T >

void regina::FuncDelete< T >::operator() | ( | T * | ptr | ) | const

inline

Calls `delete` upon the given pointer.

Parameters

  ptr | the pointer whose data should be deleted.

## operator+=() [1/4]

template<typename T >

Qitmask1<T>& regina::Qitmask1< T >::operator+= | ( | const Qitmask1< T > & | rhs | ) |

inline

Sets this to the sum of this and the given qitmask.

Each pair of qits is added modulo 4 (so, for instance, 2 + 3 = 1).

Parameters

  rhs | the qitmask to add to this.

Returns
  a reference to this qitmask.

## operator+=() [2/4]

template<typename T , typename U = T>

Qitmask2<T, U>& regina::Qitmask2< T, U >::operator+= | ( | const Qitmask2< T, U > & | rhs | ) |

inline

Sets this to the sum of this and the given qitmask.

Each pair of qits is added modulo 4 (so, for instance, 2 + 3 = 1).

Parameters

  rhs | the qitmask to add to this.

Returns
  a reference to this qitmask.

## operator+=() [3/4]

template<typename T >

Tritmask1<T>& regina::Tritmask1< T >::operator+= | ( | const Tritmask1< T > & | rhs | ) |

inline

Sets this to the sum of this and the given tritmask.

When adding trits, any digit greater than 2 will simply be replaced with 2. That is:

- 2+2 = 1+2 = 1+1 = 2;
- 0+x = x for any x.

Parameters

  rhs | the tritmask to add to this.

Returns
  a reference to this tritmask.

## operator+=() [4/4]

template<typename T , typename U = T>

Tritmask2<T, U>& regina::Tritmask2< T, U >::operator+= | ( | const Tritmask2< T, U > & | rhs | ) |

inline

Sets this to the sum of this and the given tritmask.

When adding trits, any digit greater than 2 will simply be replaced with 2. That is:

- 2+2 = 1+2 = 1+1 = 2;
- 0+x = x for any x.

Parameters

  rhs | the tritmask to add to this.

Returns
  a reference to this tritmask.

## operator-=() [1/7]

Bitmask & regina::Bitmask::operator-= | ( | const Bitmask & | other | ) |

inline

Sets this to the set difference of this and the given bitmask.

Every bit that is set in other will be cleared in this bitmask.

Precondition
  This and the given bitmask have the same length.

Parameters

  other | the bitmask to XOR with this.

Returns
  a reference to this bitmask.

## operator-=() [2/7]

template<typename T >

Bitmask1<T>& regina::Bitmask1< T >::operator-= | ( | const Bitmask1< T > & | other | ) |

inline

Sets this to the set difference of this and the given bitmask.

Every bit that is set in other will be cleared in this bitmask.

Parameters

  other | the bitmask to XOR with this.

Returns
  a reference to this bitmask.

## operator-=() [3/7]

template<typename T , typename U = T>

Bitmask2<T, U>& regina::Bitmask2< T, U >::operator-= | ( | const Bitmask2< T, U > & | other | ) |

inline

Sets this to the set difference of this and the given bitmask.

Every bit that is set in other will be cleared in this bitmask.

Parameters

  other | the bitmask to XOR with this.

Returns
  a reference to this bitmask.

## operator-=() [4/7]

template<typename T >

Qitmask1<T>& regina::Qitmask1< T >::operator-= | ( | const Qitmask1< T > & | rhs | ) |

inline

Sets this to the difference of this and the given qitmask.

Each pair of qits is subtracted modulo 4 (so, for instance, 1 - 3 = 2).

Parameters

  rhs | the qitmask to subtract from this.

Returns
  a reference to this qitmask.

## operator-=() [5/7]

template<typename T , typename U = T>

Qitmask2<T, U>& regina::Qitmask2< T, U >::operator-= | ( | const Qitmask2< T, U > & | rhs | ) |

inline

Sets this to the difference of this and the given qitmask.

Each pair of qits is subtracted modulo 4 (so, for instance, 1 - 3 = 2).

Parameters

  rhs | the qitmask to subtract from this.

Returns
  a reference to this qitmask.

## operator-=() [6/7]

template<typename T >

Tritmask1<T>& regina::Tritmask1< T >::operator-= | ( | const Tritmask1< T > & | rhs | ) |

inline

Sets this to the difference of this and the given tritmask.

When subtracting trits, any "negative digit" will simply be replaced with zero. That is:

- 2-0 = 2, 2-1 = 1, and 2-2 = 0;
- 1-0 = 1, and 1-1 = 1-2 = 0;
- 0-x = 0 for any x.

Parameters

  rhs | the tritmask to subtract from this.

Returns
  a reference to this tritmask.

## operator-=() [7/7]

template<typename T , typename U = T>

Tritmask2<T, U>& regina::Tritmask2< T, U >::operator-= | ( | const Tritmask2< T, U > & | rhs | ) |

inline

Sets this to the difference of this and the given tritmask.

When subtracting trits, any "negative digit" will simply be replaced with zero. That is:

- 2-0 = 2, 2-1 = 1, and 2-2 = 0;
- 1-0 = 1, and 1-1 = 1-2 = 0;
- 0-x = 0 for any x.

Parameters

  rhs | the tritmask to subtract from this.

Returns
  a reference to this tritmask.

## operator<()

bool regina::BoolSet::operator< | ( | const BoolSet & | other | ) | const

inline

Determines if this set is a proper subset of the given set.

Parameters

  other | the set to compare with this.

Returns
  `true` if and only if this is a proper subset of the given set.

## operator<<() [1/8]

std::ostream& regina::operator<< | ( | std::ostream & | out,
|  | const Bitmask & | mask
| ) |  |

Writes the given bitmask to the given output stream as a sequence of zeroes and ones.

Since the length of the bitmask is not stored, the number of bits written might be greater than the length initially assigned to this bitmask (specifically, the length will be rounded up to the next "raw unit of storage").

Python:\n Not present.

Parameters

  out | the output stream to which to write.
  mask | the bitmask to write.

Returns
  a reference to the given output stream.

## operator<<() [2/8]

template<typename T >

std::ostream& regina::operator<< | ( | std::ostream & | out,
|  | const Bitmask1< T > & | mask
| ) |  |

Writes the given bitmask to the given output stream as a sequence of zeroes and ones.

Since the length of the bitmask is not stored, the number of bits written will be 8 * sizeof(T).

Python:\n Not present.

Parameters

  out | the output stream to which to write.
  mask | the bitmask to write.

Returns
  a reference to the given output stream.

## operator<<() [3/8]

template<typename T , typename U >

std::ostream& regina::operator<< | ( | std::ostream & | out,
|  | const Bitmask2< T, U > & | mask
| ) |  |

Writes the given bitmask to the given output stream as a sequence of zeroes and ones.

Since the length of the bitmask is not stored, the number of bits written will be 8 * sizeof(T) + 8 * sizeof(U).

Python:\n Not present.

Parameters

  out | the output stream to which to write.
  mask | the bitmask to write.

Returns
  a reference to the given output stream.

## operator<<() [4/8]

std::ostream& regina::operator<< | ( | std::ostream & | out,
|  | const BoolSet & | set
| ) |  |

Writes the given boolean set to the given output stream.

The set will be written in the form `{ true, false }`, `{ true }`, `{ false }` or `{ }`.

Parameters

  out | the output stream to which to write.
  set | the boolean set to write.

Returns
  a reference to out.

## operator<<() [5/8]

template<typename T >

std::ostream& regina::operator<< | ( | std::ostream & | out,
|  | const Qitmask1< T > & | mask
| ) |  |

Writes the given qitmask to the given output stream as a sequence of digits (0, 1, 2 and/or 3).

Since the length of the qitmask is not stored, the number of qits written will be 8 * sizeof(T).

Python:\n Not present.

Parameters

  out | the output stream to which to write.
  mask | the qitmask to write.

Returns
  a reference to the given output stream.

## operator<<() [6/8]

template<typename T , typename U >

std::ostream& regina::operator<< | ( | std::ostream & | out,
|  | const Qitmask2< T, U > & | mask
| ) |  |

Writes the given qitmask to the given output stream as a sequence of digits (0, 1, 2 and/or 3).

Since the length of the qitmask is not stored, the number of qits written will be 8 * sizeof(T) + 8 * sizeof(U).

Python:\n Not present.

Parameters

  out | the output stream to which to write.
  mask | the qitmask to write.

Returns
  a reference to the given output stream.

## operator<<() [7/8]

template<typename T >

std::ostream& regina::operator<< | ( | std::ostream & | out,
|  | const Tritmask1< T > & | mask
| ) |  |

Writes the given tritmask to the given output stream as a sequence of digits (0, 1 and/or 2).

Since the length of the tritmask is not stored, the number of trits written will be 8 * sizeof(T).

Python:\n Not present.

Parameters

  out | the output stream to which to write.
  mask | the tritmask to write.

Returns
  a reference to the given output stream.

## operator<<() [8/8]

template<typename T , typename U >

std::ostream& regina::operator<< | ( | std::ostream & | out,
|  | const Tritmask2< T, U > & | mask
| ) |  |

Writes the given tritmask to the given output stream as a sequence of digits (0, 1 and/or 2).

Since the length of the tritmask is not stored, the number of trits written will be 8 * sizeof(T) + 8 * sizeof(U).

Python:\n Not present.

Parameters

  out | the output stream to which to write.
  mask | the tritmask to write.

Returns
  a reference to the given output stream.

## operator<=() [1/4]

bool regina::Bitmask::operator<= | ( | const Bitmask & | other | ) | const

inline

Determines whether this bitmask is entirely contained within the given bitmask.

For this routine to return `true`, every bit that is set in this bitmask must also be set in the given bitmask.

Precondition
  This and the given bitmask have the same length.

Warning
  This operation does not compare bitmasks lexicographically; moreover, it only describes a partial order, not a total order. To compare bitmasks lexicographically, use lessThan() instead.

Parameters

  other | the bitmask to compare against this.

Returns
  `true` if and only if this bitmask is entirely contained within the given bitmask.

## operator<=() [2/4]

template<typename T >

bool regina::Bitmask1< T >::operator<= | ( | const Bitmask1< T > & | other | ) | const

inline

Determines whether this bitmask is entirely contained within the given bitmask.

For this routine to return `true`, every bit that is set in this bitmask must also be set in the given bitmask.

Warning
  This operation does not compare bitmasks lexicographically; moreover, it only describes a partial order, not a total order. To compare bitmasks lexicographically, use lessThan() instead.

Parameters

  other | the bitmask to compare against this.

Returns
  `true` if and only if this bitmask is entirely contained within the given bitmask.

## operator<=() [3/4]

template<typename T , typename U = T>

bool regina::Bitmask2< T, U >::operator<= | ( | const Bitmask2< T, U > & | other | ) | const

inline

Determines whether this bitmask is entirely contained within the given bitmask.

For this routine to return `true`, every bit that is set in this bitmask must also be set in the given bitmask.

Warning
  This operation does not compare bitmasks lexicographically; moreover, it only describes a partial order, not a total order. To compare bitmasks lexicographically, use lessThan() instead.

Parameters

  other | the bitmask to compare against this.

Returns
  `true` if and only if this bitmask is entirely contained within the given bitmask.

## operator<=() [4/4]

bool regina::BoolSet::operator<= | ( | const BoolSet & | other | ) | const

inline

Determines if this set is a subset of (possibly equal to) the given set.

Parameters

  other | the set to compare with this.

Returns
  `true` if and only if this is a subset of the given set.

## operator=() [1/15]

BoolSet & regina::BoolSet::operator= | ( | bool | member | ) |

inline

Sets this set to the single member set containing the given element.

Parameters

  member | the single element to include in this set.

Returns
  a reference to this set.

## operator=() [2/15]

Bitmask & regina::Bitmask::operator= | ( | const Bitmask & | other | ) |

inline

Sets this bitmask to a copy of the given bitmask.

If this bitmask is invalid, this assignment operator can be used to initialise it with a length.

If this bitmask has already been initialised to a different length from that of the given bitmask, the length of this bitmask will be changed accordingly.

If the given bitmask is invalid, this bitmask will become invalid also. Invalid bitmasks must be assigned a length using reset(size_t) or this assignment operator.

Parameters

  other | the bitmask to clone.

Returns
  a reference to this bitmask.

## operator=() [3/15]

template<typename T >

Bitmask1<T>& regina::Bitmask1< T >::operator= | ( | const Bitmask1< T > & | other | ) |

inline

Sets this bitmask to a copy of the given bitmask.

Parameters

  other | the bitmask to clone.

Returns
  a reference to this bitmask.

## operator=() [4/15]

template<typename T , typename U = T>

Bitmask2<T, U>& regina::Bitmask2< T, U >::operator= | ( | const Bitmask2< T, U > & | other | ) |

inline

Sets this bitmask to a copy of the given bitmask.

Parameters

  other | the bitmask to clone.

Returns
  a reference to this bitmask.

## operator=() [5/15]

BoolSet & regina::BoolSet::operator= | ( | const BoolSet & | cloneMe | ) |

inline

Sets this set to be identical to the given set.

Parameters

  cloneMe | the set whose value this set will take.

Returns
  a reference to this set.

## operator=() [6/15]

template<typename T>

Flags<T>& regina::Flags< T >::operator= | ( | const Flags< T > & | rhs | ) |

inline

Sets this flag set to contain a copy of the given flag set.

Parameters

  rhs | the new value of this flag set.

Returns
  a reference to this flag set.

## operator=() [7/15]

template<typename T, template< typename Stored > class Storage = StoreValue>

const Property<T, Storage>& regina::Property< T, Storage >::operator= | ( | const Property< T, Storage > & | newValue | ) |

inline

Copies the given property into this property.

If the given property is marked as known, its value will be copied and this property will also be marked as known. Otherwise this property will be marked as unknown.

Parameters

  newValue | the property to copy into this property.

Returns
  a reference to this property.

## operator=() [8/15]

template<typename T >

Qitmask1<T>& regina::Qitmask1< T >::operator= | ( | const Qitmask1< T > & | other | ) |

inline

Sets this qitmask to a copy of the given qitmask.

Parameters

  other | the qitmask to clone.

Returns
  a reference to this qitmask.

## operator=() [9/15]

template<typename T , typename U = T>

Qitmask2<T, U>& regina::Qitmask2< T, U >::operator= | ( | const Qitmask2< T, U > & | other | ) |

inline

Sets this qitmask to a copy of the given qitmask.

Parameters

  other | the qitmask to clone.

Returns
  a reference to this qitmask.

## operator=() [10/15]

template<class T>

SafePointeeBase& regina::SafePointeeBase< T >::operator= | ( | const SafePointeeBase< T > & |  | ) |

delete

Prevent derived classes from accidentally calling the assignment operator.

## operator=() [11/15]

template<class T >

SafePtr<T>& regina::SafePtr< T >::operator= | ( | const SafePtr< T > & |  | ) |

delete

Disable the default assignment operator.

## operator=() [12/15]

template<typename T >

Tritmask1<T>& regina::Tritmask1< T >::operator= | ( | const Tritmask1< T > & | other | ) |

inline

Sets this tritmask to a copy of the given tritmask.

Parameters

  other | the tritmask to clone.

Returns
  a reference to this tritmask.

## operator=() [13/15]

template<typename T , typename U = T>

Tritmask2<T, U>& regina::Tritmask2< T, U >::operator= | ( | const Tritmask2< T, U > & | other | ) |

inline

Sets this tritmask to a copy of the given tritmask.

Parameters

  other | the tritmask to clone.

Returns
  a reference to this tritmask.

## operator=() [14/15]

template<typename T, template< typename Stored > class Storage = StoreValue>

QueryType regina::Property< T, Storage >::operator= | ( | InitType | newValue | ) |

inline

Assigns a new value to this property.

The property will be marked as known.

Parameters

  newValue | the new value to assign to this property.

Returns
  the new value of this property.

## operator=() [15/15]

template<typename T>

Flags<T>& regina::Flags< T >::operator= | ( | T | rhs | ) |

inline

Sets this flag set to contain precisely the given flag only.

Parameters

  rhs | the new value of this flag set.

Returns
  a reference to this flag set.

## operator==() [1/10]

bool regina::Bitmask::operator== | ( | const Bitmask & | other | ) | const

inline

Determines whether this and the given bitmask are identical.

Precondition
  This and the given bitmask have the same length.

Parameters

  other | the bitmask to compare against this.

Returns
  `true` if and only if this and the given bitmask are identical.

## operator==() [2/10]

template<typename T >

bool regina::Bitmask1< T >::operator== | ( | const Bitmask1< T > & | other | ) | const

inline

Determines whether this and the given bitmask are identical.

Parameters

  other | the bitmask to compare against this.

Returns
  `true` if and only if this and the given bitmask are identical.

## operator==() [3/10]

template<typename T , typename U = T>

bool regina::Bitmask2< T, U >::operator== | ( | const Bitmask2< T, U > & | other | ) | const

inline

Determines whether this and the given bitmask are identical.

Parameters

  other | the bitmask to compare against this.

Returns
  `true` if and only if this and the given bitmask are identical.

## operator==() [4/10]

bool regina::BoolSet::operator== | ( | const BoolSet & | other | ) | const

inline

Determines if this set is equal to the given set.

Parameters

  other | the set to compare with this.

Returns
  `true` if and only if this and the given set are equal.

## operator==() [5/10]

template<typename T>

bool regina::Flags< T >::operator== | ( | const Flags< T > & | rhs | ) | const

inline

Determines whether this set is precisely equal to the given flag set.

Parameters

  rhs | the flag set to test this against.

Returns
  `true` if and only if this and the given flag set are identical.

## operator==() [6/10]

template<typename T >

bool regina::Qitmask1< T >::operator== | ( | const Qitmask1< T > & | other | ) | const

inline

Determines whether this and the given qitmask are identical.

Parameters

  other | the qitmask to compare against this.

Returns
  `true` if and only if this and the given qitmask are identical.

## operator==() [7/10]

template<typename T , typename U = T>

bool regina::Qitmask2< T, U >::operator== | ( | const Qitmask2< T, U > & | other | ) | const

inline

Determines whether this and the given qitmask are identical.

Parameters

  other | the qitmask to compare against this.

Returns
  `true` if and only if this and the given qitmask are identical.

## operator==() [8/10]

template<typename T >

bool regina::Tritmask1< T >::operator== | ( | const Tritmask1< T > & | other | ) | const

inline

Determines whether this and the given tritmask are identical.

Parameters

  other | the tritmask to compare against this.

Returns
  `true` if and only if this and the given tritmask are identical.

## operator==() [9/10]

template<typename T , typename U = T>

bool regina::Tritmask2< T, U >::operator== | ( | const Tritmask2< T, U > & | other | ) | const

inline

Determines whether this and the given tritmask are identical.

Parameters

  other | the tritmask to compare against this.

Returns
  `true` if and only if this and the given tritmask are identical.

## operator==() [10/10]

template<typename T>

bool regina::Flags< T >::operator== | ( | T | rhs | ) | const

inline

Determines whether this set is precisely equal to the given flag.

Parameters

  rhs | the flag to test this against.

Returns
  `true` if and only if this and the given flag are identical.

## operator>()

bool regina::BoolSet::operator> | ( | const BoolSet & | other | ) | const

inline

Determines if this set is a proper superset of the given set.

Parameters

  other | the set to compare with this.

Returns
  `true` if and only if this is a proper superset of the given set.

## operator>=()

bool regina::BoolSet::operator>= | ( | const BoolSet & | other | ) | const

inline

Determines if this set is a superset of (possibly equal to) the given set.

Parameters

  other | the set to compare with this.

Returns
  `true` if and only if this is a superset of the given set.

## operator^() [1/3]

BoolSet regina::BoolSet::operator^ | ( | const BoolSet & | other | ) | const

inline

Returns the symmetric difference of this set and the given set.

The result is a set containing precisely the elements that belong to one but not both of the original sets. This set is not changed.

Parameters

  other | the set whose symmetric difference with this set is to be found.

Returns
  the symmetric difference of this and the given set.

## operator^() [2/3]

template<typename T>

Flags<T> regina::Flags< T >::operator^ | ( | const Flags< T > & | rhs | ) | const

inline

Returns the bitwise XOR of this and the given flag set.

This flag set is not changed.

Parameters

  rhs | the flag set to combine with this set.

Returns
  the combination of this and the given flag set.

## operator^() [3/3]

template<typename T>

Flags<T> regina::Flags< T >::operator^ | ( | T | rhs | ) | const

inline

Returns the bitwise XOR of this set and the given flag.

This flag set is not changed.

Parameters

  rhs | the flag to combine with this set.

Returns
  the combination of this set and the given flag.

## operator^=() [1/6]

Bitmask & regina::Bitmask::operator^= | ( | const Bitmask & | other | ) |

inline

Sets this to the exclusive disjunction (XOR) of this and the given bitmask.

Every bit that is set in other will be flipped in this bitmask.

Precondition
  This and the given bitmask have the same length.

Parameters

  other | the bitmask to XOR with this.

Returns
  a reference to this bitmask.

## operator^=() [2/6]

template<typename T >

Bitmask1<T>& regina::Bitmask1< T >::operator^= | ( | const Bitmask1< T > & | other | ) |

inline

Sets this to the exclusive disjunction (XOR) of this and the given bitmask.

Every bit that is set in other will be flipped in this bitmask.

Parameters

  other | the bitmask to XOR with this.

Returns
  a reference to this bitmask.

## operator^=() [3/6]

template<typename T , typename U = T>

Bitmask2<T, U>& regina::Bitmask2< T, U >::operator^= | ( | const Bitmask2< T, U > & | other | ) |

inline

Sets this to the exclusive disjunction (XOR) of this and the given bitmask.

Every bit that is set in other will be flipped in this bitmask.

Parameters

  other | the bitmask to XOR with this.

Returns
  a reference to this bitmask.

## operator^=() [4/6]

BoolSet & regina::BoolSet::operator^= | ( | const BoolSet & | other | ) |

inline

Sets this set to be the symmetric difference of this and the given set.

The result is a set containing precisely the elements that belong to one but not both of the original sets. Note that this set will be modified.

Parameters

  other | the set whose symmetric difference with this set is to be found.

Returns
  a reference to this set.

## operator^=() [5/6]

template<typename T>

Flags<T>& regina::Flags< T >::operator^= | ( | const Flags< T > & | rhs | ) |

inline

Changes this flag set by taking a bitwise XOR with the given flag set.

Parameters

  rhs | the flag set to combine with this set.

Returns
  a reference to this flag set.

## operator^=() [6/6]

template<typename T>

Flags<T>& regina::Flags< T >::operator^= | ( | T | rhs | ) |

inline

Changes this flag set by taking a bitwise XOR with the given flag.

Parameters

  rhs | the flag to combine with this set.

Returns
  a reference to this flag set.

## operator|() [1/3]

BoolSet regina::BoolSet::operator| | ( | const BoolSet & | other | ) | const

inline

Returns the union of this set with the given set.

The result is a set containing precisely the elements that belong to either of the original sets. This set is not changed.

Parameters

  other | the set to union with this set.

Returns
  the union of this and the given set.

## operator|() [2/3]

template<typename T>

Flags<T> regina::Flags< T >::operator| | ( | const Flags< T > & | rhs | ) | const

inline

Returns the bitwise OR of this and the given flag set.

This flag set is not changed.

Parameters

  rhs | the flag set to combine with this set.

Returns
  the combination of this and the given flag set.

## operator|() [3/3]

template<typename T>

Flags<T> regina::Flags< T >::operator| | ( | T | rhs | ) | const

inline

Returns the bitwise OR of this set and the given flag.

This flag set is not changed.

Parameters

  rhs | the flag to combine with this set.

Returns
  the combination of this set and the given flag.

## operator|=() [1/6]

Bitmask & regina::Bitmask::operator|= | ( | const Bitmask & | other | ) |

inline

Sets this to the union of this and the given bitmask.

Every bit that is set in other will be set in this bitmask.

Precondition
  This and the given bitmask have the same length.

Parameters

  other | the bitmask to union with this.

Returns
  a reference to this bitmask.

## operator|=() [2/6]

template<typename T >

Bitmask1<T>& regina::Bitmask1< T >::operator|= | ( | const Bitmask1< T > & | other | ) |

inline

Sets this to the union of this and the given bitmask.

Every bit that is set in other will be set in this bitmask.

Parameters

  other | the bitmask to union with this.

Returns
  a reference to this bitmask.

## operator|=() [3/6]

template<typename T , typename U = T>

Bitmask2<T, U>& regina::Bitmask2< T, U >::operator|= | ( | const Bitmask2< T, U > & | other | ) |

inline

Sets this to the union of this and the given bitmask.

Every bit that is set in other will be set in this bitmask.

Parameters

  other | the bitmask to union with this.

Returns
  a reference to this bitmask.

## operator|=() [4/6]

BoolSet & regina::BoolSet::operator|= | ( | const BoolSet & | other | ) |

inline

Sets this set to be the union of this and the given set.

The result is a set containing precisely the elements that belong to either of the original sets. Note that this set will be modified.

Parameters

  other | the set to union with this set.

Returns
  a reference to this set.

## operator|=() [5/6]

template<typename T>

Flags<T>& regina::Flags< T >::operator|= | ( | const Flags< T > & | rhs | ) |

inline

Changes this flag set by taking a bitwise OR with the given flag set.

Parameters

  rhs | the flag set to combine with this set.

Returns
  a reference to this flag set.

## operator|=() [6/6]

template<typename T>

Flags<T>& regina::Flags< T >::operator|= | ( | T | rhs | ) |

inline

Changes this flag set by taking a bitwise OR with the given flag.

Parameters

  rhs | the flag to combine with this set.

Returns
  a reference to this flag set.

## operator~()

BoolSet regina::BoolSet::operator~ | ( |  | ) | const

inline

Returns the complement of this set.

The result is a set containing precisely the elements that this set does not contain. This set is not changed.

Returns
  the complement of this set.

## overflow()

int_type regina::i18n::IConvStreamBuffer::overflow | ( | int_type | c | ) |

Sends buffered data to the destination output stream, converting between character sets en route.

The buffer will be flushed as far as possible, and any invalid characters will be replaced with one or more question marks. If the buffer ends in an incomplete multibyte character, this incomplete character will be held back (since it presumably needs to be combined with later input).

Parameters

  c | an extra character to send that did not fit in the internal buffer, or EOF if we simply wish to flush the buffer.

Returns
  0 on success, or EOF on error.

## parse_chunk()

void regina::xml::XMLParser::parse_chunk | ( | const std::string & | s | ) |

inline

Parses the given chunk of XML.

Parameters

  s | the chunk of XML to parse.

## parse_stream()

static void regina::xml::XMLParser::parse_stream | ( | XMLParserCallback & | callback,
|  | std::istream & | file,
|  | unsigned | chunkSize = `1024`
| ) |  |

static

Parses an entire XML file.

The given stream will be read from until end-of-file is reached.

Parameters

  callback | the object providing the routines to call when particular XML components are encountered during parsing.
  file | the stream from which the raw XML will be read.
  chunkSize | the number of characters to read and process at a time (this is the size of each string that will be passed to parse_chunk()).

## Property()

template<typename T, template< typename Stored > class Storage = StoreValue>

regina::Property< T, Storage >::Property | ( |  | ) |

inline

Constructor.

This property is initially marked as unknown.

## push_back()

template<typename T>

void regina::MarkedVector< T >::push_back | ( | T * | item | ) |

inline

Pushes the given item onto the end of this vector.

The array index stored inside item will be modified accordingly.

The caller retains reponsibility for the ownership of item. This class will make no attempt to deallocate item when it is removed or when this vector is eventually destroyed.

Precondition
  The given item does not already belong to some other MarkedVector.

Parameters

  item | the item to add to this vector.

## Qitmask1() [1/2]

template<typename T >

regina::Qitmask1< T >::Qitmask1 | ( |  | ) |

inline

Creates a new qitmask with all qits set to 0.

## Qitmask1() [2/2]

template<typename T >

regina::Qitmask1< T >::Qitmask1 | ( | const Qitmask1< T > & | cloneMe | ) |

inline

Creates a clone of the given qitmask.

Parameters

  cloneMe | the qitmask to clone.

## Qitmask2() [1/2]

template<typename T , typename U = T>

regina::Qitmask2< T, U >::Qitmask2 | ( |  | ) |

inline

Creates a new qitmask with all qits set to 0.

## Qitmask2() [2/2]

template<typename T , typename U = T>

regina::Qitmask2< T, U >::Qitmask2 | ( | const Qitmask2< T, U > & | cloneMe | ) |

inline

Creates a clone of the given qitmask.

Parameters

  cloneMe | the qitmask to clone.

## refill()

template<typename T>
template<typename Iterator >

void regina::MarkedVector< T >::refill | ( | Iterator | begin,
|  | Iterator | end
| ) |  |

inline

Empties this vector and refills it with the given range of items.

Calling this routine is equivalent to calling clear() followed by push_back() for each item in the range from begin to end. Its implementation, however, is a little more efficient.

The algorithm only makes a single pass through the given range of iterators.

Template Parameters

  Iterator | an input iterator type, whose dereference operator returns a pointer of type `T*`.

Parameters

  begin | an iterator that points to the beginning of the range of items with which to refill this vector.
  end | an iterator that points past the end of the range of items with which to refill this vector.

## removeFalse()

void regina::BoolSet::removeFalse | ( |  | ) |

inline

Removes `false` from this set if it is present.

## removeTrue()

void regina::BoolSet::removeTrue | ( |  | ) |

inline

Removes `true` from this set if it is present.

## reset() [1/11]

template<typename T >

void regina::Tritmask1< T >::reset | ( |  | ) |

inline

Sets all trits of this tritmask to 0.

## reset() [2/11]

template<typename T >

void regina::Qitmask1< T >::reset | ( |  | ) |

inline

Sets all qits of this qitmask to 0.

## reset() [3/11]

void regina::Bitmask::reset | ( |  | ) |

inline

Sets all bits of this bitmask to `false`.

Warning
  The length of this bitmask must already have been initialised. In particular, if the default constructor was used, you must call the one-argument reset(size_t) before you can use this routine.

## reset() [4/11]

template<typename T , typename U = T>

void regina::Tritmask2< T, U >::reset | ( |  | ) |

inline

Sets all trits of this tritmask to 0.

## reset() [5/11]

template<typename T , typename U = T>

void regina::Qitmask2< T, U >::reset | ( |  | ) |

inline

Sets all qits of this qitmask to 0.

## reset() [6/11]

template<typename T >

void regina::Bitmask1< T >::reset | ( |  | ) |

inline

Sets all bits of this bitmask to `false`.

## reset() [7/11]

template<typename T , typename U = T>

void regina::Bitmask2< T, U >::reset | ( |  | ) |

inline

Sets all bits of this bitmask to `false`.

## reset() [8/11]

void regina::Bitmask::reset | ( | size_t | length | ) |

inline

Resizes this bitmask to the given length and sets all bits to `false`.

This routine can be used to change the length (number of bits) of the bitmask if desired.

Parameters

  length | the number of bits to store in this bitmask; this must be at least one.

## reset() [9/11]

template<typename T >

void regina::Bitmask1< T >::reset | ( | size_t |  | ) |

inline

Sets all bits of this bitmask to `false`.

The integer argument is merely for compatibility with Bitmask::reset(size_t), and will be ignored.

## reset() [10/11]

template<typename T , typename U = T>

void regina::Bitmask2< T, U >::reset | ( | size_t |  | ) |

inline

Sets all bits of this bitmask to `false`.

The integer argument is merely for compatibility with Bitmask::reset(size_t), and will be ignored.

## reset() [11/11]

template<class T >

void regina::SafePtr< T >::reset | ( | T * | object = `0` | ) |

inline

Resets this to point to the given object.

This behaves in a similar manner to destroying the old safe pointer and constructing a new one: in particular, the old pointee may be destroyed if it meets the conditions outlined in the class notes above.

Parameters

  object | the new pointee. This may be `null`.

## SafePointeeBase() [1/2]

template<class T >

regina::SafePointeeBase< T >::SafePointeeBase | ( |  | ) |

inline protected

Default constructor.

## SafePointeeBase() [2/2]

template<class T>

regina::SafePointeeBase< T >::SafePointeeBase | ( | const SafePointeeBase< T > & |  | ) |

delete

Prevent derived classes from accidentally calling the copy constructor.

A derived class' copy constructor by default calls the protected default constructor, which it should because it sets the remnant_ to zero on the copied object.

## SafePtr() [1/3]

template<class T >

regina::SafePtr< T >::SafePtr | ( |  | ) |

inline

Constructs a new null pointer.

## SafePtr() [2/3]

template<class T >
template<class Y >

regina::SafePtr< T >::SafePtr | ( | const SafePtr< Y > & | other | ) |

inline

Copy constructor.

This constructor can also be used to cast a SafePtr for a derived class Y to a SafePtr for a base class T.

Precondition
  the class T (whose constructor is called) is a base class of Y.

Parameters

  other | the pointer to copy.

## SafePtr() [3/3]

template<class T >

regina::SafePtr< T >::SafePtr | ( | T * | object | ) |

inline

Constructs a new safe pointer that points to the given object.

Parameters

  object | the pointee. This may be `null`.

## set() [1/10]

template<typename ForwardIterator >

void regina::Bitmask::set | ( | ForwardIterator | indexBegin,
|  | ForwardIterator | indexEnd,
|  | bool | value
| ) |  |

inline

Sets all bits in the given sorted list to the given value.

This is a convenience routine for setting many bits at once. The indices of the bits to set should be sorted and stored in some container, such as a std::set or a C-style array. This routine takes iterators over this container, and sets the bits at the corresponding indices to the given value.

For example, the following code would set bits 3, 5 and 6 to `true:`

std::vector<unsigned> indices;
indices.push(3); indices.push(5); indices.push(6);
bitmask.set(indices.begin(), indices.end(), true);

Likewise, the following code would set bits 1, 4 and 7 to `false:`

unsigned indices[3] = { 1, 4, 7 };
bitmask.set(indices, indices + 3, false);

All other bits of this bitmask are unaffected by this routine.

Precondition
  ForwardIterator is a forward iterator type that iterates over integer values.
  The list of indices described by these iterators is in sorted order. This is to allow optimisations for larger bitmask types.
  All indices in the given list are at least zero and strictly less than the length of this bitmask.

Parameters

  indexBegin | the beginning of the iterator range containing the sorted indices of the bits to set.
  indexEnd | the end of the iterator range containing the sorted indices of the bits to set.
  value | the value that will be assigned to each of the corresponding bits.

## set() [2/10]

template<typename T >
template<typename ForwardIterator >

void regina::Bitmask1< T >::set | ( | ForwardIterator | indexBegin,
|  | ForwardIterator | indexEnd,
|  | bool | value
| ) |  |

inline

Sets all bits in the given sorted list to the given value.

This is a convenience routine for setting many bits at once. The indices of the bits to set should be sorted and stored in some container, such as a std::set or a C-style array. This routine takes iterators over this container, and sets the bits at the corresponding indices to the given value.

For example, the following code would set bits 3, 5 and 6 to `true:`

std::vector<unsigned> indices;
indices.push(3); indices.push(5); indices.push(6);
bitmask.set(indices.begin(), indices.end(), true);

Likewise, the following code would set bits 1, 4 and 7 to `false:`

unsigned indices[3] = { 1, 4, 7 };
bitmask.set(indices, indices + 3, false);

All other bits of this bitmask are unaffected by this routine.

Precondition
  ForwardIterator is a forward iterator type that iterates over integer values.
  The list of indices described by these iterators is in sorted order. This is to allow optimisations for larger bitmask types.
  All indices in the given list are between 0 and (8 * sizeof(T) - 1) inclusive.

Parameters

  indexBegin | the beginning of the iterator range containing the sorted indices of the bits to set.
  indexEnd | the end of the iterator range containing the sorted indices of the bits to set.
  value | the value that will be assigned to each of the corresponding bits.

## set() [3/10]

template<typename T , typename U = T>
template<typename ForwardIterator >

void regina::Bitmask2< T, U >::set | ( | ForwardIterator | indexBegin,
|  | ForwardIterator | indexEnd,
|  | bool | value
| ) |  |

inline

Sets all bits in the given sorted list to the given value.

This is a convenience routine for setting many bits at once. The indices of the bits to set should be sorted and stored in some container, such as a std::set or a C-style array. This routine takes iterators over this container, and sets the bits at the corresponding indices to the given value.

For example, the following code would set bits 3, 5 and 6 to `true:`

std::vector<unsigned> indices;
indices.push(3); indices.push(5); indices.push(6);
bitmask.set(indices.begin(), indices.end(), true);

Likewise, the following code would set bits 1, 4 and 7 to `false:`

unsigned indices[3] = { 1, 4, 7 };
bitmask.set(indices, indices + 3, false);

All other bits of this bitmask are unaffected by this routine.

Precondition
  ForwardIterator is a forward iterator type that iterates over integer values.
  The list of indices described by these iterators is in sorted order. This is to allow optimisations for larger bitmask types.
  All indices in the given list are between 0 and (8 * sizeof(T) + 8 * sizeof(U) - 1) inclusive.

Parameters

  indexBegin | the beginning of the iterator range containing the sorted indices of the bits to set.
  indexEnd | the end of the iterator range containing the sorted indices of the bits to set.
  value | the value that will be assigned to each of the corresponding bits.

## set() [4/10]

void regina::Bitmask::set | ( | size_t | index,
|  | bool | value
| ) |  |

inline

Sets the given bit of this bitmask to the given value.

Parameters

  index | indicates which bit to set; this must be at least zero and strictly less than the length of this bitmask.
  value | the value that will be assigned to the (index)th bit.

## set() [5/10]

template<typename T >

void regina::Bitmask1< T >::set | ( | size_t | index,
|  | bool | value
| ) |  |

inline

Sets the given bit of this bitmask to the given value.

Parameters

  index | indicates which bit to set; this must be between 0 and (8 * sizeof(T) - 1) inclusive.
  value | the value that will be assigned to the (index)th bit.

## set() [6/10]

template<typename T , typename U = T>

void regina::Bitmask2< T, U >::set | ( | size_t | index,
|  | bool | value
| ) |  |

inline

Sets the given bit of this bitmask to the given value.

Parameters

  index | indicates which bit to set; this must be between 0 and (8 * sizeof(T) + 8 * sizeof(U) - 1) inclusive.
  value | the value that will be assigned to the (index)th bit.

## set() [7/10]

template<typename T >

void regina::Tritmask1< T >::set | ( | unsigned | index,
|  | char | value
| ) |  |

inline

Sets the given trit of this tritmask to the given value.

Parameters

  index | indicates which trit to set; this must be between 0 and (8 * sizeof(T) - 1) inclusive.
  value | the value that will be assigned to the (index)th trit; this must be 0, 1 or 2.

## set() [8/10]

template<typename T >

void regina::Qitmask1< T >::set | ( | unsigned | index,
|  | char | value
| ) |  |

inline

Sets the given qit of this qitmask to the given value.

Parameters

  index | indicates which qit to set; this must be between 0 and (8 * sizeof(T) - 1) inclusive.
  value | the value that will be assigned to the (index)th qit; this must be 0, 1, 2 or 3.

## set() [9/10]

template<typename T , typename U = T>

void regina::Tritmask2< T, U >::set | ( | unsigned | index,
|  | char | value
| ) |  |

inline

Sets the given trit of this tritmask to the given value.

Parameters

  index | indicates which trit to set; this must be between 0 and (8 * sizeof(T) + 8 * sizeof(U) - 1) inclusive.
  value | the value that will be assigned to the (index)th trit; this must be 0, 1 or 2.

## set() [10/10]

template<typename T , typename U = T>

void regina::Qitmask2< T, U >::set | ( | unsigned | index,
|  | char | value
| ) |  |

inline

Sets the given qit of this qitmask to the given value.

Parameters

  index | indicates which qit to set; this must be between 0 and (8 * sizeof(T) + 8 * sizeof(U) - 1) inclusive.
  value | the value that will be assigned to the (index)th qit; this must be 0, 1, 2 or 3.

## setByteCode()

void regina::BoolSet::setByteCode | ( | unsigned char | code | ) |

inline

Sets this boolean set to that represented by the given byte code.

See byteCode() for more information on byte codes.

Precondition
  code is 0, 1, 2 or 3.

Parameters

  code | the byte code that will determine the new value of this set.

## start_document()

void regina::xml::XMLParserCallback::start_document | ( | XMLParser * | parser | ) |

inline virtual

Called at the start of the document.

Parameters

  parser | the XML parser that is currently parsing this document.

Reimplemented in regina::XMLCallback.

## start_element()

void regina::xml::XMLParserCallback::start_element | ( | const std::string & | n,
|  | const regina::xml::XMLPropertyDict & | p
| ) |  |

inline virtual

Called when an element's opening tag is encountered.

Parameters

  n | the name of the tag.
  p | a dictionary of all the properties of the tag.

Reimplemented in regina::XMLCallback.

## startsWith()

bool regina::startsWith | ( | const std::string & | str,
|  | const std::string & | prefix
| ) |  |

Determines whether the given C++ string begins with the given prefix.

Python:\n Not present.

Parameters

  str | the full C++ string to examine.
  prefix | the prefix whose presence we are testing for.

Returns
  `true` if and only if str begins with prefix.

## StoreConstPtr()

template<typename T >

regina::StoreConstPtr< T >::StoreConstPtr | ( |  | ) |

inline

Constructor that sets the held pointer to 0.

## StoreManagedPtr()

template<typename T>

regina::StoreManagedPtr< T >::StoreManagedPtr | ( |  | ) |

inline

Constructor that sets the held pointer to 0.

## stringToToken() [1/2]

std::string regina::stringToToken | ( | const char * | str | ) |

Returns a token derived from the given string.

All whitespace characters in the given string will be replaced with an underscore.

Parameters

  str | the string on which to base the token.

Returns
  the corresponding token.

## stringToToken() [2/2]

std::string regina::stringToToken | ( | const std::string & | str | ) |

Returns a token derived from the given string.

All whitespace characters in the given string will be replaced with an underscore.

Parameters

  str | the string on which to base the token.

Returns
  the corresponding token.

## stripWhitespace()

std::string regina::stripWhitespace | ( | const std::string & | str | ) |

Strips all whitespace from the beginning and end of the given C++ string.

The new stripped string is returned; the original string is not altered.

Warning
  This routine treats all strings as plain ASCII. In particular, characters are examined one at a time, and the C routine isspace() is used to identify whitespace. Use it on strings with international characters at your own peril.

Python:\n Not present.

Parameters

  str | the string to be stripped.

Returns
  the resulting stripped string.

## subscript()

template<typename T >

std::string regina::subscript | ( | T | value | ) |

Converts the given native C++ integer into a unicode subscript string.

The resulting string will be encoded using UTF-8.

Precondition
  The template argument T is either (i) a native C++ integer type, for which the standard C++11 library routine std::to_string(T) is defined; or (ii) a const reference to Integer or LargeInteger.

Python:\n This template function is instantiated in Python for types
  T = `long`, as well as const references to Integer and LargeInteger.

## superscript()

template<typename T >

std::string regina::superscript | ( | T | value | ) |

Converts the given native C++ integer into a unicode superscript string.

The resulting string will be encoded using UTF-8.

Precondition
  The template argument T is either (i) a native C++ integer type, for which the standard C++11 library routine std::to_string(T) is defined; or (ii) a const reference to Integer or LargeInteger.

Python:\n This template function is instantiated in Python for types
  T = `long`, as well as const references to Integer and LargeInteger.

## swap() [1/5]

template<typename T>

void regina::MarkedVector< T >::swap | ( | MarkedVector< T > & | other | ) |

inline

Swaps the contents of this and the given vector.

Parameters

  other | the vector whose contents are to be swapped with this.

## swap() [2/5]

template<typename T, template< typename Stored > class Storage = StoreValue>

void regina::Property< T, Storage >::swap | ( | Property< T, Storage > & | other | ) |

inline

Swaps this with the given property.

Both the known status and the values (if known) will swapped in the most efficient manner that the compiler is aware of.

Parameters

  other | the property to swap with this.

## swap() [3/5]

template<typename T >

void regina::StoreConstPtr< T >::swap | ( | StoreConstPtr< T > & | other | ) |

inline

Swaps this with the given value.

Parameters

  other | the value to swap with this.

## swap() [4/5]

template<typename T>

void regina::StoreManagedPtr< T >::swap | ( | StoreManagedPtr< T > & | other | ) |

inline protected

Swaps this with the given value.

Parameters

  other | the value to swap with this.

## swap() [5/5]

template<typename T>

void regina::StoreValue< T >::swap | ( | StoreValue< T > & | other | ) |

inline

Swaps this with the given value.

Parameters

  other | the value to swap with this.

## sync()

int regina::i18n::IConvStreamBuffer::sync | ( |  | ) |

Flushes all output buffers.

The buffers for both this stream and the destination output stream will be flushed.

Returns
  0 on success, or -1 on error.

## TrieSet()

template<typename T >

regina::TrieSet< T >::TrieSet | ( |  | ) |

inline

Constructs an empty collection of sets.

## Tritmask1() [1/2]

template<typename T >

regina::Tritmask1< T >::Tritmask1 | ( |  | ) |

inline

Creates a new tritmask with all trits set to 0.

## Tritmask1() [2/2]

template<typename T >

regina::Tritmask1< T >::Tritmask1 | ( | const Tritmask1< T > & | cloneMe | ) |

inline

Creates a clone of the given tritmask.

Parameters

  cloneMe | the tritmask to clone.

## Tritmask2() [1/2]

template<typename T , typename U = T>

regina::Tritmask2< T, U >::Tritmask2 | ( |  | ) |

inline

Creates a new tritmask with all trits set to 0.

## Tritmask2() [2/2]

template<typename T , typename U = T>

regina::Tritmask2< T, U >::Tritmask2 | ( | const Tritmask2< T, U > & | cloneMe | ) |

inline

Creates a clone of the given tritmask.

Parameters

  cloneMe | the tritmask to clone.

## truncate() [1/3]

void regina::Bitmask::truncate | ( | size_t | numBits | ) |

inline

Leaves the first numBits bits of this bitmask intact, but sets all subsequent bits to `false`.

In other words, this routine "truncates" this bitmask to the given number of bits.

This routine does not change the length of this bitmask (as passed to the contructor or to reset()).

Precondition
  numBits is at most the length of this bitmask.

Parameters

  numBits | the number of bits that will not be cleared.

## truncate() [2/3]

template<typename T >

void regina::Bitmask1< T >::truncate | ( | size_t | numBits | ) |

inline

Leaves the first numBits bits of this bitmask intact, but sets all subsequent bits to `false`.

In other words, this routine "truncates" this bitmask to the given number of bits.

This routine does not change the length of this bitmask (as passed to the contructor or to reset()).

Parameters

  numBits | the number of bits that will not be cleared.

## truncate() [3/3]

template<typename T , typename U = T>

void regina::Bitmask2< T, U >::truncate | ( | size_t | numBits | ) |

inline

Leaves the first numBits bits of this bitmask intact, but sets all subsequent bits to `false`.

In other words, this routine "truncates" this bitmask to the given number of bits.

This routine does not change the length of this bitmask (as passed to the contructor or to reset()).

Parameters

  numBits | the number of bits that will not be cleared.

## underflow()

IConvStreamBuffer::int_type regina::i18n::IConvStreamBuffer::underflow | ( |  | ) |

inline

Simply returns EOF (since this is not an input stream).

Returns
  EOF.

## value()

template<typename T, template< typename Stored > class Storage = StoreValue>

QueryType regina::Property< T, Storage >::value | ( |  | ) | const

inline

Returns the current value of this property.

If this property is marked as unknown then the results are undefined.

Precondition
  This property is currently marked as known.

Returns
  the current value of this property.

## valueOf() [1/14]

bool regina::valueOf | ( | const std::string & | str,
|  | bool & | dest
| ) |  |

Converts the entire given string to a boolean and reports whether this conversion was successful.

If the given string begins with `T`, `t` or `1`, then the string will be successfully converted to `true`. If the given string begins with `F`, `f` or `0`, then the string will be successfully converted to `false`. Otherwise the conversion will be unsuccessful and argument dest will be set to `false`.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting boolean.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [2/14]

bool regina::valueOf | ( | const std::string & | str,
|  | BoolSet & | dest
| ) |  |

Converts the entire given string to a set of booleans and reports whether this conversion was successful.

A set of booleans is represented by one of the four strings `–`, `T-`, `-F` or `TF`. If the conversion is unsuccessful, argument dest will be set to BoolSet::sNone and `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting set of booleans.

Returns
  `true` if the conversion was successful or `false` otherwise.

## valueOf() [3/14]

bool regina::valueOf | ( | const std::string & | str,
|  | double & | dest
| ) |  |

Converts the entire given string to a double precision real number and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the real number that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting real number.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [4/14]

bool regina::valueOf | ( | const std::string & | str,
|  | int & | dest
| ) |  |

Converts the entire given string to an integer and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the integer that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting integer.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [5/14]

bool regina::valueOf | ( | const std::string & | str,
|  | int8_t & | dest
| ) |  |

Converts the entire given string to an 8-bit integer and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the integer that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting 8-bit integer.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [6/14]

template<bool supportInfinity>

bool regina::valueOf | ( | const std::string & | str,
|  | IntegerBase< supportInfinity > & | dest
| ) |  |

Converts the entire given string to an arbitrary precision integer and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the integer that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting arbitrary precision integer.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [7/14]

bool regina::valueOf | ( | const std::string & | str,
|  | long & | dest
| ) |  |

Converts the entire given string to a long integer and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the integer that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting long integer.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [8/14]

bool regina::valueOf | ( | const std::string & | str,
|  | long long & | dest
| ) |  |

Converts the entire given string to a long long integer and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the integer that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting long long integer.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [9/14]

bool regina::valueOf | ( | const std::string & | str,
|  | short & | dest
| ) |  |

Converts the entire given string to a short integer and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the integer that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting short integer.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [10/14]

bool regina::valueOf | ( | const std::string & | str,
|  | uint8_t & | dest
| ) |  |

Converts the entire given string to an unsigned 8-bit integer and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the integer that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting unsigned 8-bit integer.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [11/14]

bool regina::valueOf | ( | const std::string & | str,
|  | unsigned & | dest
| ) |  |

Converts the entire given string to an unsigned integer and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the integer that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting unsigned integer.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [12/14]

bool regina::valueOf | ( | const std::string & | str,
|  | unsigned long & | dest
| ) |  |

Converts the entire given string to an unsigned long integer and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the integer that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting unsigned long integer.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [13/14]

bool regina::valueOf | ( | const std::string & | str,
|  | unsigned long long & | dest
| ) |  |

Converts the entire given string to an unsigned long long integer and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the integer that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting unsigned long long integer.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## valueOf() [14/14]

bool regina::valueOf | ( | const std::string & | str,
|  | unsigned short & | dest
| ) |  |

Converts the entire given string to an unsigned short integer and reports whether this conversion was successful.

The given string should contain no whitespace or other characters that are not a part of the integer that the string represents. If any unexpected characters are encountered, the routine will convert the string as best it can but `false` will be returned.

Python:\n Not present.

Parameters

  str | the string to convert.
  dest | the variable in which to store the resulting unsigned short integer.

Returns
  `true` if the conversion was completely successful or `false` otherwise.

## warning()

void regina::xml::XMLParserCallback::warning | ( | const std::string & | s | ) |

inline virtual

Called when a parser warning occurs.

Parameters

  s | the warning message.

Reimplemented in regina::XMLCallback.

## xmlEncodeComment()

std::string regina::xml::xmlEncodeComment | ( | const std::string & | comment | ) |

Returns the given string encoded so it is suitable for use inside an XML comment.

As well as converting special characters to XML entities, this routine will replace dashes with underscores to avoid double-hyphens (which are illegal in XML comments).

Python:\n Not present.

Parameters

  comment | the string to convert; this string will not be changed.

Returns
  the string converted to be usable inside an XML comment.

## xmlEncodeSpecialChars()

std::string regina::xml::xmlEncodeSpecialChars | ( | const std::string & | original | ) |

Returns the given string with special characters converted to XML entities.

For instance, the string `"a \< b"` would be converted to `"a \&lt; b"`.

Python:\n Not present.

Parameters

  original | the string to convert; this string will not be changed.

Returns
  the converted string with special characters replaced by XML entities.

## XMLParser()

regina::xml::XMLParser::XMLParser | ( | XMLParserCallback & | callback | ) |

Creates a new XML parser.

Parameters

  callback | the object providing the routines to call when particular XML components are encountered during parsing.

## XMLPropertyDict()

regina::xml::XMLPropertyDict::XMLPropertyDict | ( |  | ) |

inline

Create a new map.

## xmlString()

std::string regina::xml::xmlString | ( | xmlChar * | str,
|  | bool | free = `true`
| ) |  |

inline

Converts the given string from libxml into a C++ string, optionally deallocating the original libxml string.

The given libxml string str may be `null`, in which case the resulting C++ string will be the empty string.

Parameters

  str | the string to convert.
  free | `true` if the original libxml string str should be deallocated, or `false` if it should be preserved.

Returns
  the given string as a C++ string.

## xmlValueTag()

template<class T >

std::string regina::xml::xmlValueTag | ( | const std::string & | tagName,
|  | const T & | value
| ) |  |

inline

Returns an XML tag with a single property containing the given value.

The tag will be of the form `<tagName value="..."/>`.

The value itself will be written to the tag string using the standard output stream operator <<.

Precondition
  The property value when written to an output stream does not contain any special characters (such as `<` or `&`) that need to be encoded as XML entities.

Python:\n Not present.

Parameters

  tagName | the name of the XML tag to create.
  value | the value to assign to the value property of the tag.

Returns
  the corresponding XML tag.

## ~Bitmask()

regina::Bitmask::~Bitmask | ( |  | ) |

inline

Destroys this bitmask.

## ~IConvStreamBuffer()

regina::i18n::IConvStreamBuffer::~IConvStreamBuffer | ( |  | ) |

inline

Destroys this stream buffer.

This stream buffer will be closed, but the destination output stream will not be.

## ~ListOnCall()

template<typename T>

virtual regina::ListOnCall< T >::~ListOnCall | ( |  | ) |

inline virtual

Destroys this list and all of the items it contains.

## ~SafePointeeBase()

template<class T >

regina::SafePointeeBase< T >::~SafePointeeBase | ( |  | ) |

inline

Destructor.

Once this destructor is called, any SafePtr that points to this object will be aware that the object has expired and that the pointer cannot be dereferenced any longer.

## ~SafeRemnant()

template<class T >

regina::detail::SafeRemnant< T >::~SafeRemnant | ( |  | ) |

Destroys this remnant.

If the remnant is associated with a pointee, then:

- if no other C++ object claims ownership of the pointee (as determined by T::hasOwner()), then the pointee will be deleted;
- if some other C++ object does claim ownership of the pointee then the pointee will be left intact, but its reference to this remnant will be cleared.

## ~StoreManagedPtr()

template<typename T>

regina::StoreManagedPtr< T >::~StoreManagedPtr | ( |  | ) |

inline protected

Destroys the currently held value if one exists.

## ~TrieSet()

template<typename T >

regina::TrieSet< T >::~TrieSet | ( |  | ) |

inline

Destroys this collection of sets.

## ~XMLParser()

regina::xml::XMLParser::~XMLParser | ( |  | ) |

inline virtual

Destroys this XML parser.

## ~XMLParserCallback()

regina::xml::XMLParserCallback::~XMLParserCallback | ( |  | ) |

inline virtual

Default destructor that does nothing.

## Variable Documentation

## argument_type [1/3]

template<class T >

const typedef T* regina::FuncNewCopyPtr< T >::argument_type

The argument type for this unary function.

## argument_type [2/3]

template<class T >

const typedef T& regina::FuncNewCopyRef< T >::argument_type

The argument type for this unary function.

## argument_type [3/3]

template<class T >

const typedef T* regina::FuncNewClonePtr< T >::argument_type

The argument type for this unary function.

## first_argument_type

template<typename T , typename Comp = std::less<T>>

const typedef T* regina::LessDeref< T, Comp >::first_argument_type

The first argument type for this binary function.

## InitType [1/2]

template<typename T>

const typedef T& regina::StoreValue< T >::InitType

The type by which new values for the underlying property are passed.

## InitType [2/2]

template<typename T >

const typedef T* regina::StoreConstPtr< T >::InitType

The type by which new values for the underlying property are passed.

## QueryType [1/3]

template<typename T>

const typedef T& regina::StoreValue< T >::QueryType

The type by which the property value is returned to the user.

## QueryType [2/3]

template<typename T >

const typedef T* regina::StoreConstPtr< T >::QueryType

The type by which the property value is returned to the user.

## QueryType [3/3]

template<typename T>

const typedef T* regina::StoreManagedPtr< T >::QueryType

The type by which the property value is returned to the user.

## sBoth

const BoolSet regina::BoolSet::sBoth

static

The set containing both `true` and `false`.

## second_argument_type

template<typename T , typename Comp = std::less<T>>

const typedef T* regina::LessDeref< T, Comp >::second_argument_type

The second argument type for this binary function.

## sFalse

const BoolSet regina::BoolSet::sFalse

static

The set containing only `false`.

## sNone

const BoolSet regina::BoolSet::sNone

static

The empty set.

## sTrue

const BoolSet regina::BoolSet::sTrue

static

The set containing only `true`.

## value_ [1/3]

template<typename T>

T regina::StoreValue< T >::value_

protected

The held property value.

## value_ [2/3]

template<typename T >

const T* regina::StoreConstPtr< T >::value_

protected

The held property value.

## value_ [3/3]

template<typename T>

T* regina::StoreManagedPtr< T >::value_

protected

The held property value.

## Friends

## MarkedVector

template<typename T >

friend class MarkedVector

friend

Allow only MarkedVector to edit the array index.

## operator<< [1/4]

std::ostream& operator<< | ( | std::ostream & | out,
|  | const Bitmask & | mask
| ) |  |

friend

Writes the given bitmask to the given output stream as a sequence of zeroes and ones.

Since the length of the bitmask is not stored, the number of bits written might be greater than the length initially assigned to this bitmask (specifically, the length will be rounded up to the next "raw unit of storage").

Python:\n Not present.

Parameters

  out | the output stream to which to write.
  mask | the bitmask to write.

Returns
  a reference to the given output stream.

## operator<< [2/4]

std::ostream& operator<< | ( | std::ostream & | out,
|  | const BoolSet & | set
| ) |  |

friend

Writes the given boolean set to the given output stream.

The set will be written in the form `{ true, false }`, `{ true }`, `{ false }` or `{ }`.

Parameters

  out | the output stream to which to write.
  set | the boolean set to write.

Returns
  a reference to out.

## operator<< [3/4]

template<typename T >

std::ostream& operator<< | ( | std::ostream & | out,
|  | const Tritmask1< T > & | mask
| ) |  |

friend

Writes the given tritmask to the given output stream as a sequence of digits (0, 1 and/or 2).

Since the length of the tritmask is not stored, the number of trits written will be 8 * sizeof(T).

Python:\n Not present.

Parameters

  out | the output stream to which to write.
  mask | the tritmask to write.

Returns
  a reference to the given output stream.

## operator<< [4/4]

template<typename T , typename U = T>

std::ostream& operator<< | ( | std::ostream & | out,
|  | const Tritmask2< T, U > & | mask
| ) |  |

friend

Writes the given tritmask to the given output stream as a sequence of digits (0, 1 and/or 2).

Since the length of the tritmask is not stored, the number of trits written will be 8 * sizeof(T) + 8 * sizeof(U).

Python:\n Not present.

Parameters

  out | the output stream to which to write.
  mask | the tritmask to write.

Returns
  a reference to the given output stream.

Copyright © 1999-2016, The Regina development team
This software is released under the GNU General Public License, with some additional permissions; see the source code for details.
For further information, or to submit a bug or other problem, please contact Ben Burton (bab@maths.uq.edu.au).