Regina Calculation Engine
|
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... | |
Miscellaneous helper classes and functions
typedef T* regina::FuncDelete< T >::argument_type |
The argument type for this unary function.
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.
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.
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.
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.
typedef T regina::SafePtr< T >::element_type |
The pointee type.
This typedef is used by the boost infrastructure.
typedef T regina::Flags< T >::Enum |
The underlying enumeration type.
typedef T* regina::StoreManagedPtr< T >::InitType |
The type by which new values for the underlying property are passed.
typedef Storage<T>::InitType regina::Property< T, Storage >::InitType |
The type by which new values for the underlying property are passed.
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.
typedef BoolSet regina::NBoolSet |
Deprecated typedef for backward compatibility.
This typedef will be removed in a future release of Regina.
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.
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.
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.
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.
typedef Storage<T>::QueryType regina::Property< T, Storage >::QueryType |
The type by which the property value is returned to the user.
typedef T* regina::FuncNew< T >::result_type |
The return type for this generator.
typedef T* regina::FuncNewCopyPtr< T >::result_type |
The return type for this unary function.
typedef bool regina::LessDeref< T, Comp >::result_type |
The result type for this binary comparison function.
typedef T* regina::FuncNewCopyRef< T >::result_type |
The return type for this unary function.
typedef T* regina::FuncNewClonePtr< T >::result_type |
The return type for this unary function.
typedef void regina::FuncDelete< T >::result_type |
The return type for this unary function.
typedef T regina::SafePointeeBase< T >::SafePointeeType |
The type of object being pointed to.
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.
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.
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.
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.
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. |
|
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
.
true
if and only if at most one bit is set to true
.
|
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
.
true
if and only if at most one bit is set to true
.
|
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
.
true
if and only if at most one bit is set to true
. 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.
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). |
true
if decoding was successful, or false
if an unexpected input character was found or some other error occurred.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.
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. |
true
if decoding was successful, or false
if the output buffer was exhausted or an unexpected input character was found.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
.
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. |
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.
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. |
|
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**).
bytes | the number of raw input bytes. |
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.
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. |
|
inline |
|
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.
|
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.
cloneMe | the bitmask to clone. |
|
inline |
Creates a new bitmask of the given length with all bits set to false
.
length | the number of bits stored in this bitmask; this must be at least one. |
|
inline |
Creates a new bitmask with all bits set to false
.
|
inline |
Creates a clone of the given bitmask.
cloneMe | the bitmask to clone. |
|
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.
|
inline |
Creates a new bitmask with all bits set to false
.
|
inline |
Creates a clone of the given bitmask.
cloneMe | the bitmask to clone. |
|
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.
|
inline |
Returns the number of bits currently set to true
in this bitmask.
true
bits.
|
inline |
Returns the number of bits currently set to true
in this bitmask.
true
bits.
|
inline |
Returns the number of bits currently set to true
in this bitmask.
true
bits.
|
inlinestatic |
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.
x | the integer of type T to examine. |
|
inline |
Creates a new empty set.
|
inline |
Creates a set specifying whether true
and/or false
should be a member.
insertTrue | should the new set include the element true ? |
insertFalse | should the new set include the element false ? |
|
inline |
Creates a set containing a single member as given.
member | the single element to include in this set. |
|
inline |
Creates a set equal to the given set.
cloneMe | the set upon which we will base the new set. |
|
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.
|
inlinevirtual |
Called when characters are encountered.
s | the characters encountered. |
Reimplemented in regina::XMLCallback.
|
inline |
Cleans up any currently held value before the property value is changed or cleared.
This implementation does nothing.
|
inline |
Cleans up any currently held value before the property value is changed or cleared.
This implementation resets the held pointer to 0.
|
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.
|
inline |
Marks this property as unknown.
|
inline |
Clears all bits from this set that appear in the given set.
rhs | identifies the bits to clear from this set. |
|
inline |
Clears all bits from this set that appear in the given flag.
rhs | the flag to clear from this set. |
|
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.
cloneMe | a pointer to the object to clone; this may be null. |
|
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.
cloneMe | a pointer to the object to clone; this may be null. |
IConvStreamBuffer* regina::i18n::IConvStreamBuffer::close | ( | ) | ||
throw | ( | |||
) |
Closes this stream buffer.
|
static |
Returns the character encoding used in the current locale.
This is a plain string, such as "UTF-8" or "ISO-8859-1".
|
inlinevirtual |
Called when a comment is encountered.
s | the comment string. |
|
inline |
Determines if the given boolean is a member of this set.
value | the boolean to search for in this set. |
true
if and only if the given boolean is a member of this set. 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.
x | the first bitmask used to form the intersection. |
y | the first bitmask used to form the intersection. |
true
if and only if this bitmask entirely contains the intersection of x and y.
|
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.
x | the first bitmask used to form the intersection. |
y | the first bitmask used to form the intersection. |
true
if and only if this bitmask entirely contains the intersection of x and y.
|
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.
x | the first bitmask used to form the intersection. |
y | the first bitmask used to form the intersection. |
true
if and only if this bitmask entirely contains the intersection of x and y. 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.
str | the C++ string to duplicate. |
|
inline |
Removes all elements from this set.
|
inline |
Determines whether this tritmask contains all zeroes.
true
if every trit is zero, or false
otherwise.
|
inline |
Determines whether this qitmask contains all zeroes.
true
if every qit is zero, or false
otherwise.
|
inline |
Determines whether this tritmask contains all zeroes.
true
if every trit is zero, or false
otherwise.
|
inline |
Determines whether this qitmask contains all zeroes.
true
if every qit is zero, or false
otherwise.
|
inline |
|
inlinevirtual |
Called when the document is finalised.
Reimplemented in regina::XMLCallback.
|
inlinevirtual |
Called when an element's closing tag is encountered.
This is called immediately after start_element() if the opening tag is in <tag/>
format.
n | the name of the tag. |
Reimplemented in regina::XMLCallback.
|
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.
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. |
|
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.
default_ | the highest-priority flag. |
second | the second-highest-priority flag. |
last | the lowest-priority flag. |
|
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.
default_ | the highest-priority flag. |
second | the second-highest-priority flag. |
third | the third-highest-priority flag. |
last | the lowest-priority flag. |
|
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.
first | an iterator pointing to the first element to erase. |
last | an iterator pointing just beyond the last element to erase. |
|
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.
pos | an iterator pointing to the element to erase. |
|
inlinevirtual |
Called when a parser error occurs.
s | the error message. |
Reimplemented in regina::XMLCallback.
|
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.
|
inlinevirtual |
Called when a parser fatal error occurs.
s | the error message. |
Reimplemented in regina::XMLCallback.
|
inline |
Places both true
and false
into this set if they are not already present.
|
inline |
Signals that there are no more XML chunks to parse.
|
inline |
Returns the index of the first true
bit in this bitmask, or -1 if there are no true
bits.
true
bit.
|
inline |
Returns the index of the first true
bit in this bitmask, or -1 if there are no true
bits.
true
bit.
|
inline |
Returns the index of the first true
bit in this bitmask, or -1 if there are no true
bits.
true
bit.
|
inlinestatic |
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.
x | the integer of type T to examine. |
true
bit, or -1 if there are no true
bits.
|
inline |
Creates an empty flag set, with no flags set at all.
|
inline |
Creates a clone of the given flag set.
init | the flag set to clone. |
|
inline |
Creates a flag set initialised to the given value.
init | the initial value of this flag set. |
|
inline |
Negates every bit in this bitmask.
All true
bits will be set to false
and vice versa.
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!
|
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.
|
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.
|
inlinestatic |
Creates a boolean set from the given byte code.
See byteCode() for more information on byte codes.
code | the byte code from which the new set will be created. |
|
inlinestatic |
Returns the set corresponding to the given integer value.
This is suitable for file input and/or output.
|
inline |
Dereference this remnant.
|
inline |
Returns a raw pointer to the pointee, or null
if the pointee has already been destroyed.
|
inline |
Returns the value of the given bit of this bitmask.
index | indicates which bit to query; this must be at least zero and strictly less than the length of this bitmask. |
|
inline |
Returns the value of the given bit of this bitmask.
index | indicates which bit to query; this must be between 0 and (8 * sizeof(T) - 1) inclusive. |
|
inline |
Returns the value of the given bit of this bitmask.
index | indicates which bit to query; this must be between 0 and (8 * sizeof(T) + 8 * sizeof(U) - 1) inclusive. |
|
inline |
Returns the value of the given trit in this tritmask.
index | indicates which trit to query; this must be between 0 and (8 * sizeof(T) - 1) inclusive. |
|
inline |
Returns the value of the given qit in this qitmask.
index | indicates which qit to query; this must be between 0 and (8 * sizeof(T) - 1) inclusive. |
|
inline |
Returns the value of the given trit in this tritmask.
index | indicates which trit to query; this must be between 0 and (8 * sizeof(T) + 8 * sizeof(U) - 1) inclusive. |
|
inline |
Returns the value of the given qit in this qitmask.
index | indicates which qit to query; this must be between 0 and (8 * sizeof(T) + 8 * sizeof(U) - 1) inclusive. |
|
inline |
Extracts a raw pointer from the given safe pointer.
This is required for SafePtr to support the boost dereferencable concept.
ptr | a safe pointer. This may be null . |
|
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.
object | the object deriving from SafePointeeBase. |
|
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
.
rhs | the set whose presence will be tested. |
true
if and only if all of the bits of the given set are present in this set.
|
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
.
flag | the flag whose presence will be tested. |
true
if and only if all of the bits of the given flag are set.
|
inline |
Determines whether this tritmask contains at least one trit with value 2.
true
if at least one trit is 2, or false
otherwise.
|
inline |
Determines whether this tritmask contains at least one trit with value 2.
true
if at least one trit is 2, or false
otherwise.
|
inline |
Determines whether this qitmask contains at least one qit with value 3.
true
if at least one qit is 3, or false
otherwise.
|
inline |
Determines whether this qitmask contains at least one qit with value 3.
true
if at least one qit is 3, or false
otherwise. 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.
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. |
true
if a superset with the required properties was found, or false
otherwise.
|
inline |
Determines if false
is a member of this set.
true
if and only if false
is a member of this set.
|
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.
other | the qitmask to compare with this. |
true
if there is some index at which this and other both have non-zero qits, or false
otherwise.
|
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.
other | the qitmask to compare with this. |
true
if there is some index at which this and other both have non-zero qits, or false
otherwise. 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.
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. |
true
if a subset was found, or false
otherwise.
|
inline |
Determines if true
is a member of this set.
true
if and only if true
is a member of this set.
|
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
.
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. |
|
inline |
Creates a new stream buffer.
|
protectedpure 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.
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.
entry | the new set to insert. |
|
inlineprotected |
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.
item | the new item to insert. |
|
inline |
Inserts false
into this set if it is not already present.
|
inline |
Inserts true
into this set if it is not already present.
|
inline |
Returns the integer representation of this set.
This is suitable for file input and/or output.
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.
x | the first bitmask used to form the union. |
y | the first bitmask used to form the union. |
true
if and only if this bitmask is entirely contained within the union of x and y.
|
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.
x | the first bitmask used to form the union. |
y | the first bitmask used to form the union. |
true
if and only if this bitmask is entirely contained within the union of x and y.
|
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.
x | the first bitmask used to form the union. |
y | the first bitmask used to form the union. |
true
if and only if this bitmask is entirely contained within the union of x and y.
|
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.
ch | any character. |
true
if the given character is one of the base64 printable characters used in Regina, or false
if it is not.
|
inline |
Returns whether or not this property is currently marked as known.
|
inline |
Returns the index of the last true
bit in this bitmask, or -1 if there are no true
bits.
true
bit.
|
inline |
Returns the index of the last true
bit in this bitmask, or -1 if there are no true
bits.
true
bit.
|
inline |
Returns the index of the last true
bit in this bitmask, or -1 if there are no true
bits.
true
bit.
|
inlinestatic |
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.
x | the integer of type T to examine. |
true
bit, or -1 if there are no true
bits.
|
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.
other | the bitmask to compare against this. |
true
if and only if this is lexicographically strictly smaller than the given bitmask.
|
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.
other | the bitmask to compare against this. |
true
if and only if this is lexicographically strictly smaller than the given bitmask.
|
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.
other | the bitmask to compare against this. |
true
if and only if this is lexicographically strictly smaller than the given bitmask.
|
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.
|
delete |
Disable the default constructor, since all routines are static.
|
inline |
Return a value for the given key, or the empty string if the key does not exist in the map.
key | the key to look up. |
|
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.
|
inline |
Constructs a new empty vector.
|
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.
rhs | the tritmask to "max" with this. |
|
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.
rhs | the tritmask to "max" with this. |
|
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.
rhs | the tritmask to "min" with this. |
|
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.
rhs | the tritmask to "min" with this. |
|
inline |
Determines whether this tritmask contains at least one non-zero trit.
true
if at least one trit is non-zero, or false
otherwise.
|
inline |
Determines whether this qitmask contains at least one non-zero qit.
true
if at least one qit is non-zero, or false
otherwise.
|
inline |
Determines whether this tritmask contains at least one non-zero trit.
true
if at least one trit is non-zero, or false
otherwise.
|
inline |
Determines whether this qitmask contains at least one non-zero qit.
true
if at least one qit is non-zero, or false
otherwise. 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
.
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. |
|
inline |
|
inline |
Determines if this set is not equal to the given set.
other | the set to compare with this. |
true
if and only if this and the given set are not equal.
|
inline |
Determines whether this set is not equal to the given flag set.
rhs | the flag to test this against. |
true
if and only if this and the given flag set are not identical.
|
inline |
Determines whether this set is not equal to the given flag.
rhs | the flag to test this against. |
true
if and only if this and the given flag are not identical. 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.
other | the set to intersect with this set. |
|
inline |
Returns the bitwise AND of this and the given flag set.
This flag set is not changed.
rhs | the flag set to combine with this set. |
|
inline |
Returns the bitwise AND of this set and the given flag.
This flag set is not changed.
rhs | the flag to combine with this set. |
Sets this to the intersection of this and the given bitmask.
Every bit that is unset in other will be unset in this bitmask.
other | the bitmask to intersect with this. |
|
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.
other | the bitmask to intersect with this. |
|
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.
other | the bitmask to intersect with this. |
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.
other | the set to intersect with this set. |
|
inline |
Changes this flag set by taking a bitwise AND with the given flag set.
rhs | the flag set to combine with this set. |
|
inline |
Changes this flag set by taking a bitwise AND with the given flag.
rhs | the flag to combine with this set. |
|
inline |
Creates a new object using the default constructor.
|
inline |
Casts this vector to a const std::vector, thus providing access to the entire const functionality of std::vector.
|
inline |
Creates a new object using the copy constructor.
obj | the object whose data should be passed to the copy constructor. |
|
inline |
Creates a new object using the copy constructor.
ptr | the pointer whose data should (after dereferencing) be passed to the copy constructor. |
|
inline |
Creates a new object using the clone()
method.
ptr | the pointer whose corresponding object should be cloned. |
|
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.
ptr1 | a pointer to the first object under examination. |
ptr2 | a pointer to the second object under examination. |
true
if the first dereferenced object is less than the second, or false
otherwise.
|
inline |
Calls delete
upon the given pointer.
ptr | the pointer whose data should be deleted. |
|
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).
rhs | the qitmask to add to this. |
|
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).
rhs | the qitmask to add to this. |
|
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:
rhs | the tritmask to add to this. |
|
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:
rhs | the tritmask to add to this. |
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.
other | the bitmask to XOR with this. |
|
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.
other | the bitmask to XOR with this. |
|
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.
other | the bitmask to XOR with this. |
|
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).
rhs | the qitmask to subtract from this. |
|
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).
rhs | the qitmask to subtract from this. |
|
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:
rhs | the tritmask to subtract from this. |
|
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:
rhs | the tritmask to subtract from this. |
|
inline |
Determines if this set is a proper subset of the given set.
other | the set to compare with this. |
true
if and only if this is a proper subset of the given set. 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").
out | the output stream to which to write. |
mask | the bitmask to write. |
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).
out | the output stream to which to write. |
mask | the bitmask to write. |
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).
out | the output stream to which to write. |
mask | the bitmask to write. |
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 { }
.
out | the output stream to which to write. |
set | the boolean set to write. |
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).
out | the output stream to which to write. |
mask | the qitmask to write. |
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).
out | the output stream to which to write. |
mask | the qitmask to write. |
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).
out | the output stream to which to write. |
mask | the tritmask to write. |
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).
out | the output stream to which to write. |
mask | the tritmask to write. |
|
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.
other | the bitmask to compare against this. |
true
if and only if this bitmask is entirely contained within the given bitmask.
|
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.
other | the bitmask to compare against this. |
true
if and only if this bitmask is entirely contained within the given bitmask.
|
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.
other | the bitmask to compare against this. |
true
if and only if this bitmask is entirely contained within the given bitmask.
|
inline |
Determines if this set is a subset of (possibly equal to) the given set.
other | the set to compare with this. |
true
if and only if this is a subset of the given set.
|
inline |
Sets this set to the single member set containing the given element.
member | the single element to include in this set. |
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.
other | the bitmask to clone. |
|
inline |
Sets this bitmask to a copy of the given bitmask.
other | the bitmask to clone. |
|
inline |
Sets this bitmask to a copy of the given bitmask.
other | the bitmask to clone. |
Sets this set to be identical to the given set.
cloneMe | the set whose value this set will take. |
|
inline |
Sets this flag set to contain a copy of the given flag set.
rhs | the new value of this flag set. |
|
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.
newValue | the property to copy into this property. |
|
inline |
Sets this qitmask to a copy of the given qitmask.
other | the qitmask to clone. |
|
inline |
Sets this qitmask to a copy of the given qitmask.
other | the qitmask to clone. |
|
delete |
Prevent derived classes from accidentally calling the assignment operator.
|
delete |
Disable the default assignment operator.
|
inline |
Sets this tritmask to a copy of the given tritmask.
other | the tritmask to clone. |
|
inline |
Sets this tritmask to a copy of the given tritmask.
other | the tritmask to clone. |
|
inline |
Assigns a new value to this property.
The property will be marked as known.
newValue | the new value to assign to this property. |
|
inline |
Sets this flag set to contain precisely the given flag only.
rhs | the new value of this flag set. |
|
inline |
Determines whether this and the given bitmask are identical.
other | the bitmask to compare against this. |
true
if and only if this and the given bitmask are identical.
|
inline |
Determines whether this and the given bitmask are identical.
other | the bitmask to compare against this. |
true
if and only if this and the given bitmask are identical.
|
inline |
Determines whether this and the given bitmask are identical.
other | the bitmask to compare against this. |
true
if and only if this and the given bitmask are identical.
|
inline |
Determines if this set is equal to the given set.
other | the set to compare with this. |
true
if and only if this and the given set are equal.
|
inline |
Determines whether this set is precisely equal to the given flag set.
rhs | the flag set to test this against. |
true
if and only if this and the given flag set are identical.
|
inline |
Determines whether this and the given qitmask are identical.
other | the qitmask to compare against this. |
true
if and only if this and the given qitmask are identical.
|
inline |
Determines whether this and the given qitmask are identical.
other | the qitmask to compare against this. |
true
if and only if this and the given qitmask are identical.
|
inline |
Determines whether this and the given tritmask are identical.
other | the tritmask to compare against this. |
true
if and only if this and the given tritmask are identical.
|
inline |
Determines whether this and the given tritmask are identical.
other | the tritmask to compare against this. |
true
if and only if this and the given tritmask are identical.
|
inline |
Determines whether this set is precisely equal to the given flag.
rhs | the flag to test this against. |
true
if and only if this and the given flag are identical.
|
inline |
Determines if this set is a proper superset of the given set.
other | the set to compare with this. |
true
if and only if this is a proper superset of the given set.
|
inline |
Determines if this set is a superset of (possibly equal to) the given set.
other | the set to compare with this. |
true
if and only if this is a superset of the given set. 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.
other | the set whose symmetric difference with this set is to be found. |
|
inline |
Returns the bitwise XOR of this and the given flag set.
This flag set is not changed.
rhs | the flag set to combine with this set. |
|
inline |
Returns the bitwise XOR of this set and the given flag.
This flag set is not changed.
rhs | the flag to combine with this set. |
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.
other | the bitmask to XOR with this. |
|
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.
other | the bitmask to XOR with this. |
|
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.
other | the bitmask to XOR with this. |
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.
other | the set whose symmetric difference with this set is to be found. |
|
inline |
Changes this flag set by taking a bitwise XOR with the given flag set.
rhs | the flag set to combine with this set. |
|
inline |
Changes this flag set by taking a bitwise XOR with the given flag.
rhs | the flag to combine with this set. |
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.
other | the set to union with this set. |
|
inline |
Returns the bitwise OR of this and the given flag set.
This flag set is not changed.
rhs | the flag set to combine with this set. |
|
inline |
Returns the bitwise OR of this set and the given flag.
This flag set is not changed.
rhs | the flag to combine with this set. |
Sets this to the union of this and the given bitmask.
Every bit that is set in other will be set in this bitmask.
other | the bitmask to union with this. |
|
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.
other | the bitmask to union with this. |
|
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.
other | the bitmask to union with this. |
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.
other | the set to union with this set. |
|
inline |
Changes this flag set by taking a bitwise OR with the given flag set.
rhs | the flag set to combine with this set. |
|
inline |
Changes this flag set by taking a bitwise OR with the given flag.
rhs | the flag to combine with this set. |
|
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.
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).
c | an extra character to send that did not fit in the internal buffer, or EOF if we simply wish to flush the buffer. |
|
inline |
Parses the given chunk of XML.
s | the chunk of XML to parse. |
|
static |
Parses an entire XML file.
The given stream will be read from until end-of-file is reached.
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()). |
|
inline |
Constructor.
This property is initially marked as unknown.
|
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.
item | the item to add to this vector. |
|
inline |
Creates a new qitmask with all qits set to 0.
|
inline |
Creates a clone of the given qitmask.
cloneMe | the qitmask to clone. |
|
inline |
Creates a new qitmask with all qits set to 0.
|
inline |
Creates a clone of the given qitmask.
cloneMe | the qitmask to clone. |
|
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.
Iterator | an input iterator type, whose dereference operator returns a pointer of type T* . |
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. |
|
inline |
Removes false
from this set if it is present.
|
inline |
Removes true
from this set if it is present.
|
inline |
Sets all trits of this tritmask to 0.
|
inline |
Sets all qits of this qitmask to 0.
|
inline |
Sets all bits of this bitmask to false
.
|
inline |
Sets all trits of this tritmask to 0.
|
inline |
Sets all qits of this qitmask to 0.
|
inline |
Sets all bits of this bitmask to false
.
|
inline |
Sets all bits of this bitmask to false
.
|
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.
length | the number of bits to store in this bitmask; this must be at least one. |
|
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.
|
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.
|
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.
object | the new pointee. This may be null . |
|
inlineprotected |
Default constructor.
|
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.
|
inline |
Constructs a new null pointer.
|
inline |
|
inline |
Constructs a new safe pointer that points to the given object.
object | the pointee. This may be null . |
|
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:
Likewise, the following code would set bits 1, 4 and 7 to false:
All other bits of this bitmask are unaffected by this routine.
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. |
|
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:
Likewise, the following code would set bits 1, 4 and 7 to false:
All other bits of this bitmask are unaffected by this routine.
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. |
|
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:
Likewise, the following code would set bits 1, 4 and 7 to false:
All other bits of this bitmask are unaffected by this routine.
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. |
|
inline |
Sets the given bit of this bitmask to the given value.
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. |
|
inline |
Sets the given bit of this bitmask to the given value.
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. |
|
inline |
Sets the given bit of this bitmask to the given value.
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. |
|
inline |
Sets the given trit of this tritmask to the given value.
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. |
|
inline |
Sets the given qit of this qitmask to the given value.
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. |
|
inline |
Sets the given trit of this tritmask to the given value.
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. |
|
inline |
Sets the given qit of this qitmask to the given value.
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. |
|
inline |
Sets this boolean set to that represented by the given byte code.
See byteCode() for more information on byte codes.
code | the byte code that will determine the new value of this set. |
|
inlinevirtual |
Called at the start of the document.
parser | the XML parser that is currently parsing this document. |
Reimplemented in regina::XMLCallback.
|
inlinevirtual |
Called when an element's opening tag is encountered.
n | the name of the tag. |
p | a dictionary of all the properties of the tag. |
Reimplemented in regina::XMLCallback.
bool regina::startsWith | ( | const std::string & | str, |
const std::string & | prefix | ||
) |
Determines whether the given C++ string begins with the given prefix.
str | the full C++ string to examine. |
prefix | the prefix whose presence we are testing for. |
true
if and only if str begins with prefix.
|
inline |
Constructor that sets the held pointer to 0.
|
inline |
Constructor that sets the held pointer to 0.
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.
str | the string on which to base the token. |
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.
str | the string on which to base the token. |
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.
str | the string to be stripped. |
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.
long
, as well as const references to Integer and LargeInteger. 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.
long
, as well as const references to Integer and LargeInteger.
|
inline |
Swaps the contents of this and the given vector.
other | the vector whose contents are to be swapped with this. |
|
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.
other | the property to swap with this. |
|
inline |
Swaps this with the given value.
other | the value to swap with this. |
|
inlineprotected |
Swaps this with the given value.
other | the value to swap with this. |
|
inline |
Swaps this with the given value.
other | the value to swap with this. |
int regina::i18n::IConvStreamBuffer::sync | ( | ) |
Flushes all output buffers.
The buffers for both this stream and the destination output stream will be flushed.
|
inline |
Constructs an empty collection of sets.
|
inline |
Creates a new tritmask with all trits set to 0.
|
inline |
Creates a clone of the given tritmask.
cloneMe | the tritmask to clone. |
|
inline |
Creates a new tritmask with all trits set to 0.
|
inline |
Creates a clone of the given tritmask.
cloneMe | the tritmask to clone. |
|
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()).
numBits | the number of bits that will not be cleared. |
|
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()).
numBits | the number of bits that will not be cleared. |
|
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()).
numBits | the number of bits that will not be cleared. |
|
inline |
Simply returns EOF (since this is not an input stream).
|
inline |
Returns the current value of this property.
If this property is marked as unknown then the results are undefined.
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
.
str | the string to convert. |
dest | the variable in which to store the resulting boolean. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting set of booleans. |
true
if the conversion was successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting real number. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting integer. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting 8-bit integer. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting arbitrary precision integer. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting long integer. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting long long integer. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting short integer. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting unsigned 8-bit integer. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting unsigned integer. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting unsigned long integer. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting unsigned long long integer. |
true
if the conversion was completely successful or false
otherwise. 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.
str | the string to convert. |
dest | the variable in which to store the resulting unsigned short integer. |
true
if the conversion was completely successful or false
otherwise.
|
inlinevirtual |
Called when a parser warning occurs.
s | the warning message. |
Reimplemented in regina::XMLCallback.
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).
comment | the string to convert; this string will not be changed. |
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 \< b"
.
original | the string to convert; this string will not be changed. |
regina::xml::XMLParser::XMLParser | ( | XMLParserCallback & | callback | ) |
Creates a new XML parser.
callback | the object providing the routines to call when particular XML components are encountered during parsing. |
|
inline |
Create a new map.
|
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.
str | the string to convert. |
free | true if the original libxml string str should be deallocated, or false if it should be preserved. |
|
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 <<.
<
or &
) that need to be encoded as XML entities.tagName | the name of the XML tag to create. |
value | the value to assign to the value property of the tag. |
|
inline |
Destroys this bitmask.
|
inline |
Destroys this stream buffer.
This stream buffer will be closed, but the destination output stream will not be.
|
inlinevirtual |
Destroys this list and all of the items it contains.
|
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.
regina::detail::SafeRemnant< T >::~SafeRemnant | ( | ) |
Destroys this remnant.
If the remnant is associated with a pointee, then:
|
inlineprotected |
Destroys the currently held value if one exists.
|
inline |
Destroys this collection of sets.
|
inlinevirtual |
Destroys this XML parser.
|
inlinevirtual |
Default destructor that does nothing.
const typedef T* regina::FuncNewCopyPtr< T >::argument_type |
The argument type for this unary function.
const typedef T& regina::FuncNewCopyRef< T >::argument_type |
The argument type for this unary function.
const typedef T* regina::FuncNewClonePtr< T >::argument_type |
The argument type for this unary function.
const typedef T* regina::LessDeref< T, Comp >::first_argument_type |
The first argument type for this binary function.
const typedef T& regina::StoreValue< T >::InitType |
The type by which new values for the underlying property are passed.
const typedef T* regina::StoreConstPtr< T >::InitType |
The type by which new values for the underlying property are passed.
const typedef T& regina::StoreValue< T >::QueryType |
The type by which the property value is returned to the user.
const typedef T* regina::StoreConstPtr< T >::QueryType |
The type by which the property value is returned to the user.
const typedef T* regina::StoreManagedPtr< T >::QueryType |
The type by which the property value is returned to the user.
|
static |
The set containing both true
and false
.
const typedef T* regina::LessDeref< T, Comp >::second_argument_type |
The second argument type for this binary function.
|
static |
The set containing only false
.
|
static |
The empty set.
|
static |
The set containing only true
.
|
protected |
The held property value.
|
protected |
The held property value.
|
protected |
The held property value.
|
friend |
Allow only MarkedVector to edit the array index.
|
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").
out | the output stream to which to write. |
mask | the bitmask to write. |
|
friend |
Writes the given boolean set to the given output stream.
The set will be written in the form { true, false }
, { true }
, { false }
or { }
.
out | the output stream to which to write. |
set | the boolean set to write. |
|
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).
out | the output stream to which to write. |
mask | the tritmask to write. |
|
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).
out | the output stream to which to write. |
mask | the tritmask to write. |