Rosetta 3.3
Namespaces | Classes | Functions
utility::keys Namespace Reference

Keys and key-accessed containers for fast, safe object lookup. More...

Namespaces

namespace  lookup

Classes

class  AutoKey
 Automatic hidden index key abstract base class. More...
class  ClassKeyMap
 Keyed-access map with key subset map for each client class. More...
class  ClassKeyVector
 Keyed-access vector with key subset map for each client class. More...
class  Key
 Hidden index key interface class. More...
class  Key2Tuple
 2-tuple meta-key More...
class  Key2Vector
 2-key meta-key More...
class  Key3Tuple
 3-tuple meta-key More...
class  Key3Vector
 3-key meta-key More...
class  Key4Tuple
 4-tuple meta-key More...
class  Key4Vector
 4-key meta-key More...
class  KeyCount
 Key counter functor. More...
class  KeyLess
 Key member comparison functor template. More...
class  PointerKeyLess
 Key member comparison functor template for pointers. More...
class  KeyLookup
 Key lookup map and collection. More...
class  KeyMapTraits
 KeyMap traits class. More...
class  KeySetTraits
 KeySet traits class. More...
class  KeyVector
 Keyed-access vector. More...
class  KeyVectorTraits
 KeyVector traits class. More...
class  NoClient
 Default key policy class when no client is needed to distinguish key type. More...
class  SmallKeyMap
 Keyed-access map with key subset map. More...
class  SmallKeyVector
 Keyed-access vector with key subset map. More...
class  UserKey
 User-created hidden index key abstract base class. More...
class  VariantKey
 Variant key class. More...

Functions

template<typename O , typename S , typename C >
bool operator== (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKey == AutoKey.
template<typename O , typename S , typename C >
bool operator!= (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKey != AutoKey.
template<typename O , typename S , typename C >
bool operator< (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKey < AutoKey.
template<typename O , typename S , typename C >
bool operator<= (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKey <= AutoKey.
template<typename O , typename S , typename C >
bool operator>= (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKey >= AutoKey.
template<typename O , typename S , typename C >
bool operator> (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKey > AutoKey.
template<typename O , typename S , typename C >
bool sequential (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKeys are sequential?
template<typename K , typename T , typename C >
void swap (ClassKeyMap< K, T, C > &a, ClassKeyMap< K, T, C > &b)
 swap( ClassKeyMap, ClassKeyMap )
template<typename K , typename T , typename C >
bool operator== (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap == ClassKeyMap.
template<typename K , typename T , typename C >
bool operator!= (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap != ClassKeyMap.
template<typename K , typename T , typename C >
bool operator< (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap < ClassKeyMap.
template<typename K , typename T , typename C >
bool operator> (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap > ClassKeyMap.
template<typename K , typename T , typename C >
bool operator<= (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap <= ClassKeyMap.
template<typename K , typename T , typename C >
bool operator>= (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap >= ClassKeyMap.
template<typename K , typename T , typename C >
void swap (ClassKeyVector< K, T, C > &a, ClassKeyVector< K, T, C > &b)
 swap( ClassKeyVector, ClassKeyVector )
template<typename K , typename T , typename C >
bool operator== (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector == ClassKeyVector.
template<typename K , typename T , typename C >
bool operator!= (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector != ClassKeyVector.
template<typename K , typename T , typename C >
bool operator< (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector < ClassKeyVector.
template<typename K , typename T , typename C >
bool operator> (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector > ClassKeyVector.
template<typename K , typename T , typename C >
bool operator<= (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector <= ClassKeyVector.
template<typename K , typename T , typename C >
bool operator>= (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector >= ClassKeyVector.
bool operator== (Key const &a, Key const &b)
 Key == Key.
bool operator!= (Key const &a, Key const &b)
 Key != Key.
bool operator< (Key const &a, Key const &b)
 Key < Key.
bool operator<= (Key const &a, Key const &b)
 Key <= Key.
bool operator>= (Key const &a, Key const &b)
 Key >= Key.
bool operator> (Key const &a, Key const &b)
 Key > Key.
bool comparable (Key const &a, Key const &b)
 Are Keys of Comparable Types?
template<typename K1 , typename K2 >
bool operator== (Key2Tuple< K1, K2 > const &a, Key2Tuple< K1, K2 > const &b)
 Key2Tuple == Key2Tuple.
template<typename K1 , typename K2 >
bool operator!= (Key2Tuple< K1, K2 > const &a, Key2Tuple< K1, K2 > const &b)
 Key2Tuple != Key2Tuple.
template<typename K1 , typename K2 >
bool operator< (Key2Tuple< K1, K2 > const &a, Key2Tuple< K1, K2 > const &b)
 Key2Tuple < Key2Tuple.
template<typename K >
bool operator== (Key2Vector< K > const &a, Key2Vector< K > const &b)
 Key2Vector == Key2Vector.
template<typename K >
bool operator!= (Key2Vector< K > const &a, Key2Vector< K > const &b)
 Key2Vector != Key2Vector.
template<typename K >
bool operator< (Key2Vector< K > const &a, Key2Vector< K > const &b)
 Key2Vector < Key2Vector.
template<typename K1 , typename K2 , typename K3 >
bool operator== (Key3Tuple< K1, K2, K3 > const &a, Key3Tuple< K1, K2, K3 > const &b)
 Key3Tuple == Key3Tuple.
template<typename K1 , typename K2 , typename K3 >
bool operator!= (Key3Tuple< K1, K2, K3 > const &a, Key3Tuple< K1, K2, K3 > const &b)
 Key3Tuple != Key3Tuple.
template<typename K1 , typename K2 , typename K3 >
bool operator< (Key3Tuple< K1, K2, K3 > const &a, Key3Tuple< K1, K2, K3 > const &b)
 Key3Tuple < Key3Tuple.
template<typename K >
bool operator== (Key3Vector< K > const &a, Key3Vector< K > const &b)
 Key3Vector == Key3Vector.
template<typename K >
bool operator!= (Key3Vector< K > const &a, Key3Vector< K > const &b)
 Key3Vector != Key3Vector.
template<typename K >
bool operator< (Key3Vector< K > const &a, Key3Vector< K > const &b)
 Key3Vector < Key3Vector.
template<typename K1 , typename K2 , typename K3 , typename K4 >
bool operator== (Key4Tuple< K1, K2, K3, K4 > const &a, Key4Tuple< K1, K2, K3, K4 > const &b)
 Key4Tuple == Key4Tuple.
template<typename K1 , typename K2 , typename K3 , typename K4 >
bool operator!= (Key4Tuple< K1, K2, K3, K4 > const &a, Key4Tuple< K1, K2, K3, K4 > const &b)
 Key4Tuple != Key4Tuple.
template<typename K1 , typename K2 , typename K3 , typename K4 >
bool operator< (Key4Tuple< K1, K2, K3, K4 > const &a, Key4Tuple< K1, K2, K3, K4 > const &b)
 Key4Tuple < Key4Tuple.
template<typename K >
bool operator== (Key4Vector< K > const &a, Key4Vector< K > const &b)
 Key4Vector == Key4Vector.
template<typename K >
bool operator!= (Key4Vector< K > const &a, Key4Vector< K > const &b)
 Key4Vector != Key4Vector.
template<typename K >
bool operator< (Key4Vector< K > const &a, Key4Vector< K > const &b)
 Key4Vector < Key4Vector.
template<typename K , typename T >
void swap (KeyVector< K, T > &a, KeyVector< K, T > &b)
 swap( KeyVector, KeyVector )
template<typename K , typename T >
bool operator== (KeyVector< K, T > const &a, KeyVector< K, T > const &b)
 KeyVector == KeyVector.
template<typename K , typename T >
bool operator!= (KeyVector< K, T > const &a, KeyVector< K, T > const &b)
 KeyVector != KeyVector.
template<typename K , typename T >
void swap (SmallKeyMap< K, T > &a, SmallKeyMap< K, T > &b)
 swap( SmallKeyMap, SmallKeyMap )
template<typename K , typename T >
bool operator== (SmallKeyMap< K, T > const &a, SmallKeyMap< K, T > const &b)
 SmallKeyMap == SmallKeyMap.
template<typename K , typename T >
bool operator!= (SmallKeyMap< K, T > const &a, SmallKeyMap< K, T > const &b)
 SmallKeyMap != SmallKeyMap.
template<typename K , typename T >
void swap (SmallKeyVector< K, T > &a, SmallKeyVector< K, T > &b)
 swap( SmallKeyVector, SmallKeyVector )
template<typename K , typename T >
bool operator== (SmallKeyVector< K, T > const &a, SmallKeyVector< K, T > const &b)
 SmallKeyVector == SmallKeyVector.
template<typename K , typename T >
bool operator!= (SmallKeyVector< K, T > const &a, SmallKeyVector< K, T > const &b)
 SmallKeyVector != SmallKeyVector.
template<typename O , typename S , typename C >
bool operator== (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey == UserKey.
template<typename O , typename S , typename C >
bool operator!= (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey != UserKey.
template<typename O , typename S , typename C >
bool operator< (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey < UserKey.
template<typename O , typename S , typename C >
bool operator<= (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey <= UserKey.
template<typename O , typename S , typename C >
bool operator>= (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey >= UserKey.
template<typename O , typename S , typename C >
bool operator> (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey > UserKey.
template<typename O , typename S , typename C >
bool sequential (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKeys are sequential?
template<typename K >
bool operator== (VariantKey< K > const &a, VariantKey< K > const &b)
 VariantKey == VariantKey.
template<typename K >
bool operator!= (VariantKey< K > const &a, VariantKey< K > const &b)
 VariantKey != VariantKey.
template<typename K >
bool operator< (VariantKey< K > const &a, VariantKey< K > const &b)
 VariantKey < VariantKey.

Detailed Description

Keys and key-accessed containers for fast, safe object lookup.

The utility::keys package provides key classes and key-accessed containers. The keys are intended for use as named "indexes" for object lookup. Keys are like safer, more flexible enums when the integral value of the key doesn't have a meaning in the code. Keys have a hidden index value that only the containers can access, forcing application code to be written in terms of named keys instead of "magic" index numbers or unsafe enums. This makes it safe and fast to add new keys or change their order. Key class hierarchies add a capability that enums lack and the key classes hold additional identifier strings. Keys can also be added to key collections in separate source files, which is important for application "pluggability".

The hidden index allows fast vector-based containers instead of much slower map or hash based containers. Special containers are provided for fast vector-based lookup when the container holds only a subset of the possible keys.

Key is the root interface class for all the key types.

AutoKey sets a unique index for each key of an AutoKey type. AutoKey has template arguments for the type of object being key-accessed and a class that is considered the client/user of the keys, giving the developer fine-grained control over the key types and collections. AutoKey is intended for fixed collections of keys that are created sequentially one time: if you create AutoKeys in a loop the assigned indexes will eventually overflow.

UserKey is like AutoKey but the index can be set at the time of creation and then only accessed externally by friend class containers. UserKey is intended for key collections that may be created multiple times or for which the user needs to control the assigned indexes.

AutoKey and UserKey are abstract base classes: the application abstract and concrete key classes derived from them can specify the friend container classes that can access their hidden index and any special data or behavior they need.

VariantKey can be used to hold a key of any type derived from a base key type.

KeyTuple classes are provided for combining 2, 3, or 4 keys of any key types into a single meta-key. KeyVector classes are similar but for keys of the same type. Note that std::pair could play this role for 2 keys and boost::tuple for multiple keys but the KeyTuple and KeyVector classes provide a consistent, natural interface without creating a dependence on the Boost library.

Keys in a collection can be added to the associated KeyLookup class to provide a way to lookup keys by their identifiers and to iterate over the keys.

There are two types of containers provided that use the keys, those that share a common index map with all containers of that key, value, and client type and those for which each container has its own index map. These containers act a lot like hash maps except that they make exactly two fast index lookups for each user lookup by key, which gives higher performance than typical hash maps.

ClassKeyVector behaves like a vector that is indexed by its key type and for which all containers of that ClassKeyVector type share the same mapping from active keys to the inner vector. A client class template argument, in addition to the key and value type arguments, allows fine-grained control over the key collections that share an index map. The index map in ClassKeyVector is static so the size of the map (the highest index of any active key) and sparsity of the active keys is not generally a storage issue.

ClassKeyMap is like ClassKeyVector except that it stores a std::pair of the key and the mapped value for use when the key of each element is needed while iterating through the container.

SmallKeyVector behaves like a vector that is indexed by its key type where each SmallKeyVector has its own set of active keys and map from active keys to the inner vector. The index map is a member in each SmallKeyVector so it is not space-efficient for large key sets with sparse active key subsets. A hash map should be used instead when the storage use outweighs the lookup speed benefit of SmallKeyVector.

SmallKeyMap is like SmallKeyVector except that it stores a std::pair of the key and the mapped value for use when the key of each element is needed while iterating through the container.


Function Documentation

bool utility::keys::comparable ( Key const &  a,
Key const &  b 
)

Are Keys of Comparable Types?

References utility::keys::Key::comparable.

template<typename K , typename T , typename C >
bool utility::keys::operator!= ( ClassKeyMap< K, T, C > const &  a,
ClassKeyMap< K, T, C > const &  b 
)
template<typename K , typename T , typename C >
bool utility::keys::operator!= ( ClassKeyVector< K, T, C > const &  a,
ClassKeyVector< K, T, C > const &  b 
)
template<typename K >
bool utility::keys::operator!= ( Key2Vector< K > const &  a,
Key2Vector< K > const &  b 
)
template<typename K >
bool utility::keys::operator!= ( VariantKey< K > const &  a,
VariantKey< K > const &  b 
)
template<typename K1 , typename K2 , typename K3 >
bool utility::keys::operator!= ( Key3Tuple< K1, K2, K3 > const &  a,
Key3Tuple< K1, K2, K3 > const &  b 
)
template<typename K >
bool utility::keys::operator!= ( Key3Vector< K > const &  a,
Key3Vector< K > const &  b 
)
bool utility::keys::operator!= ( Key const &  a,
Key const &  b 
)

Key != Key.

Note:
TYpe and index-based polymorphic equality

References utility::keys::Key::equals().

template<typename K1 , typename K2 , typename K3 , typename K4 >
bool utility::keys::operator!= ( Key4Tuple< K1, K2, K3, K4 > const &  a,
Key4Tuple< K1, K2, K3, K4 > const &  b 
)
template<typename K >
bool utility::keys::operator!= ( Key4Vector< K > const &  a,
Key4Vector< K > const &  b 
)
template<typename O , typename S , typename C >
bool utility::keys::operator!= ( AutoKey< O, S, C > const &  a,
AutoKey< O, S, C > const &  b 
)

AutoKey != AutoKey.

Note:
Index-based equality
template<typename K , typename T >
bool utility::keys::operator!= ( KeyVector< K, T > const &  a,
KeyVector< K, T > const &  b 
)
template<typename K , typename T >
bool utility::keys::operator!= ( SmallKeyMap< K, T > const &  a,
SmallKeyMap< K, T > const &  b 
)
template<typename K , typename T >
bool utility::keys::operator!= ( SmallKeyVector< K, T > const &  a,
SmallKeyVector< K, T > const &  b 
)
template<typename K1 , typename K2 >
bool utility::keys::operator!= ( Key2Tuple< K1, K2 > const &  a,
Key2Tuple< K1, K2 > const &  b 
)
template<typename O , typename S , typename C >
bool utility::keys::operator!= ( UserKey< O, S, C > const &  a,
UserKey< O, S, C > const &  b 
)

UserKey != UserKey.

Note:
Index-based equality
template<typename K >
bool utility::keys::operator< ( VariantKey< K > const &  a,
VariantKey< K > const &  b 
)
template<typename K >
bool utility::keys::operator< ( Key2Vector< K > const &  a,
Key2Vector< K > const &  b 
)

Key2Vector < Key2Vector.

Note:
Lexicographic (full) ordering => Key2Vector is suitable for use as a map key or set element
template<typename K , typename T , typename C >
bool utility::keys::operator< ( ClassKeyVector< K, T, C > const &  a,
ClassKeyVector< K, T, C > const &  b 
)
template<typename K1 , typename K2 , typename K3 >
bool utility::keys::operator< ( Key3Tuple< K1, K2, K3 > const &  a,
Key3Tuple< K1, K2, K3 > const &  b 
)

Key3Tuple < Key3Tuple.

Note:
Lexicographic (full) ordering => Key3Tuple is suitable for use as a map key or set element
template<typename K >
bool utility::keys::operator< ( Key3Vector< K > const &  a,
Key3Vector< K > const &  b 
)

Key3Vector < Key3Vector.

Note:
Lexicographic (full) ordering => Key3Vector is suitable for use as a map key or set element
template<typename K1 , typename K2 , typename K3 , typename K4 >
bool utility::keys::operator< ( Key4Tuple< K1, K2, K3, K4 > const &  a,
Key4Tuple< K1, K2, K3, K4 > const &  b 
)

Key4Tuple < Key4Tuple.

Note:
Lexicographic (full) ordering => Key4Tuple is suitable for use as a map key or set element
template<typename K , typename T , typename C >
bool utility::keys::operator< ( ClassKeyMap< K, T, C > const &  a,
ClassKeyMap< K, T, C > const &  b 
)
template<typename K >
bool utility::keys::operator< ( Key4Vector< K > const &  a,
Key4Vector< K > const &  b 
)

Key4Vector < Key4Vector.

Note:
Lexicographic (full) ordering => Key4Vector is suitable for use as a map key or set element
bool utility::keys::operator< ( Key const &  a,
Key const &  b 
)

Key < Key.

Note:
Index-based ordering
Needed for use as key in associative containers

References utility::keys::Key::less_than().

template<typename O , typename S , typename C >
bool utility::keys::operator< ( UserKey< O, S, C > const &  a,
UserKey< O, S, C > const &  b 
)

UserKey < UserKey.

Note:
Index-based ordering
Needed for use as key in associative containers
template<typename O , typename S , typename C >
bool utility::keys::operator< ( AutoKey< O, S, C > const &  a,
AutoKey< O, S, C > const &  b 
)

AutoKey < AutoKey.

Note:
Index-based ordering
Needed for use as key in associative containers
template<typename K1 , typename K2 >
bool utility::keys::operator< ( Key2Tuple< K1, K2 > const &  a,
Key2Tuple< K1, K2 > const &  b 
)

Key2Tuple < Key2Tuple.

Note:
Lexicographic (full) ordering => Key2Tuple is suitable for use as a map key or set element
template<typename K , typename T , typename C >
bool utility::keys::operator<= ( ClassKeyVector< K, T, C > const &  a,
ClassKeyVector< K, T, C > const &  b 
)
template<typename O , typename S , typename C >
bool utility::keys::operator<= ( UserKey< O, S, C > const &  a,
UserKey< O, S, C > const &  b 
)

UserKey <= UserKey.

Note:
Index-based ordering
template<typename O , typename S , typename C >
bool utility::keys::operator<= ( AutoKey< O, S, C > const &  a,
AutoKey< O, S, C > const &  b 
)

AutoKey <= AutoKey.

Note:
Index-based ordering
template<typename K , typename T , typename C >
bool utility::keys::operator<= ( ClassKeyMap< K, T, C > const &  a,
ClassKeyMap< K, T, C > const &  b 
)
bool utility::keys::operator<= ( Key const &  a,
Key const &  b 
)

Key <= Key.

Note:
Index-based ordering
Needed for use as key in associative containers

References utility::keys::Key::equals(), and utility::keys::Key::less_than().

template<typename O , typename S , typename C >
bool utility::keys::operator== ( UserKey< O, S, C > const &  a,
UserKey< O, S, C > const &  b 
)

UserKey == UserKey.

Note:
Index-based equality
template<typename O , typename S , typename C >
bool utility::keys::operator== ( AutoKey< O, S, C > const &  a,
AutoKey< O, S, C > const &  b 
)

AutoKey == AutoKey.

Note:
Index-based equality
template<typename K >
bool utility::keys::operator== ( Key2Vector< K > const &  a,
Key2Vector< K > const &  b 
)
template<typename K , typename T , typename C >
bool utility::keys::operator== ( ClassKeyVector< K, T, C > const &  a,
ClassKeyVector< K, T, C > const &  b 
)
template<typename K , typename T , typename C >
bool utility::keys::operator== ( ClassKeyMap< K, T, C > const &  a,
ClassKeyMap< K, T, C > const &  b 
)
template<typename K >
bool utility::keys::operator== ( VariantKey< K > const &  a,
VariantKey< K > const &  b 
)
template<typename K >
bool utility::keys::operator== ( Key4Vector< K > const &  a,
Key4Vector< K > const &  b 
)
template<typename K1 , typename K2 , typename K3 , typename K4 >
bool utility::keys::operator== ( Key4Tuple< K1, K2, K3, K4 > const &  a,
Key4Tuple< K1, K2, K3, K4 > const &  b 
)
template<typename K , typename T >
bool utility::keys::operator== ( SmallKeyMap< K, T > const &  a,
SmallKeyMap< K, T > const &  b 
)
bool utility::keys::operator== ( Key const &  a,
Key const &  b 
)

Key == Key.

Note:
TYpe and index-based polymorphic equality

References utility::keys::Key::equals().

template<typename K1 , typename K2 , typename K3 >
bool utility::keys::operator== ( Key3Tuple< K1, K2, K3 > const &  a,
Key3Tuple< K1, K2, K3 > const &  b 
)
template<typename K >
bool utility::keys::operator== ( Key3Vector< K > const &  a,
Key3Vector< K > const &  b 
)
template<typename K , typename T >
bool utility::keys::operator== ( KeyVector< K, T > const &  a,
KeyVector< K, T > const &  b 
)
template<typename K , typename T >
bool utility::keys::operator== ( SmallKeyVector< K, T > const &  a,
SmallKeyVector< K, T > const &  b 
)
template<typename K1 , typename K2 >
bool utility::keys::operator== ( Key2Tuple< K1, K2 > const &  a,
Key2Tuple< K1, K2 > const &  b 
)
template<typename K , typename T , typename C >
bool utility::keys::operator> ( ClassKeyMap< K, T, C > const &  a,
ClassKeyMap< K, T, C > const &  b 
)
template<typename O , typename S , typename C >
bool utility::keys::operator> ( AutoKey< O, S, C > const &  a,
AutoKey< O, S, C > const &  b 
)

AutoKey > AutoKey.

Note:
Index-based ordering
bool utility::keys::operator> ( Key const &  a,
Key const &  b 
)

Key > Key.

Note:
Index-based ordering
Needed for use as key in associative containers

References utility::keys::Key::less_than().

template<typename K , typename T , typename C >
bool utility::keys::operator> ( ClassKeyVector< K, T, C > const &  a,
ClassKeyVector< K, T, C > const &  b 
)
template<typename O , typename S , typename C >
bool utility::keys::operator> ( UserKey< O, S, C > const &  a,
UserKey< O, S, C > const &  b 
)

UserKey > UserKey.

Note:
Index-based ordering
template<typename O , typename S , typename C >
bool utility::keys::operator>= ( UserKey< O, S, C > const &  a,
UserKey< O, S, C > const &  b 
)

UserKey >= UserKey.

Note:
Index-based ordering
template<typename K , typename T , typename C >
bool utility::keys::operator>= ( ClassKeyVector< K, T, C > const &  a,
ClassKeyVector< K, T, C > const &  b 
)
bool utility::keys::operator>= ( Key const &  a,
Key const &  b 
)

Key >= Key.

Note:
Index-based ordering
Needed for use as key in associative containers

References utility::keys::Key::equals(), and utility::keys::Key::less_than().

template<typename K , typename T , typename C >
bool utility::keys::operator>= ( ClassKeyMap< K, T, C > const &  a,
ClassKeyMap< K, T, C > const &  b 
)
template<typename O , typename S , typename C >
bool utility::keys::operator>= ( AutoKey< O, S, C > const &  a,
AutoKey< O, S, C > const &  b 
)

AutoKey >= AutoKey.

Note:
Index-based ordering
template<typename O , typename S , typename C >
bool utility::keys::sequential ( AutoKey< O, S, C > const &  a,
AutoKey< O, S, C > const &  b 
)

AutoKeys are sequential?

Note:
Index-based ordering
template<typename O , typename S , typename C >
bool utility::keys::sequential ( UserKey< O, S, C > const &  a,
UserKey< O, S, C > const &  b 
)

UserKeys are sequential?

Note:
Index-based ordering
template<typename K , typename T , typename C >
void utility::keys::swap ( ClassKeyMap< K, T, C > &  a,
ClassKeyMap< K, T, C > &  b 
) [inline]
template<typename K , typename T , typename C >
void utility::keys::swap ( ClassKeyVector< K, T, C > &  a,
ClassKeyVector< K, T, C > &  b 
) [inline]

swap( ClassKeyVector, ClassKeyVector )

References utility::keys::ClassKeyVector< K, T, C >::swap(), and utility::vectorL< L, T, A >::swap().

template<typename K , typename T >
void utility::keys::swap ( KeyVector< K, T > &  a,
KeyVector< K, T > &  b 
) [inline]
template<typename K , typename T >
void utility::keys::swap ( SmallKeyMap< K, T > &  a,
SmallKeyMap< K, T > &  b 
) [inline]

swap( SmallKeyMap, SmallKeyMap )

References utility::keys::SmallKeyMap< K, T >::swap(), and utility::vectorL< L, T, A >::swap().

template<typename K , typename T >
void utility::keys::swap ( SmallKeyVector< K, T > &  a,
SmallKeyVector< K, T > &  b 
) [inline]

swap( SmallKeyVector, SmallKeyVector )

References utility::keys::SmallKeyVector< K, T >::swap(), and utility::vectorL< L, T, A >::swap().

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines