Rosetta  2020.37
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
Namespaces | Classes | Functions
utility::keys Namespace Reference

Namespaces

 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  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  PointerKeyLess
 Key member comparison functor template for pointers. 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. More...
 
template<typename O , typename S , typename C >
bool operator!= (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKey != AutoKey. More...
 
template<typename O , typename S , typename C >
bool operator< (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKey < AutoKey. More...
 
template<typename O , typename S , typename C >
bool operator<= (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKey <= AutoKey. More...
 
template<typename O , typename S , typename C >
bool operator>= (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKey >= AutoKey. More...
 
template<typename O , typename S , typename C >
bool operator> (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKey > AutoKey. More...
 
template<typename O , typename S , typename C >
bool sequential (AutoKey< O, S, C > const &a, AutoKey< O, S, C > const &b)
 AutoKeys are sequential? More...
 
template<typename K , typename T , typename C >
void swap (ClassKeyMap< K, T, C > &a, ClassKeyMap< K, T, C > &b)
 swap( ClassKeyMap, ClassKeyMap ) More...
 
template<typename K , typename T , typename C >
bool operator== (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap == ClassKeyMap. More...
 
template<typename K , typename T , typename C >
bool operator!= (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap != ClassKeyMap. More...
 
template<typename K , typename T , typename C >
bool operator< (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap < ClassKeyMap. More...
 
template<typename K , typename T , typename C >
bool operator> (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap > ClassKeyMap. More...
 
template<typename K , typename T , typename C >
bool operator<= (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap <= ClassKeyMap. More...
 
template<typename K , typename T , typename C >
bool operator>= (ClassKeyMap< K, T, C > const &a, ClassKeyMap< K, T, C > const &b)
 ClassKeyMap >= ClassKeyMap. More...
 
template<typename K , typename T , typename C >
void swap (ClassKeyVector< K, T, C > &a, ClassKeyVector< K, T, C > &b)
 swap( ClassKeyVector, ClassKeyVector ) More...
 
template<typename K , typename T , typename C >
bool operator== (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector == ClassKeyVector. More...
 
template<typename K , typename T , typename C >
bool operator!= (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector != ClassKeyVector. More...
 
template<typename K , typename T , typename C >
bool operator< (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector < ClassKeyVector. More...
 
template<typename K , typename T , typename C >
bool operator> (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector > ClassKeyVector. More...
 
template<typename K , typename T , typename C >
bool operator<= (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector <= ClassKeyVector. More...
 
template<typename K , typename T , typename C >
bool operator>= (ClassKeyVector< K, T, C > const &a, ClassKeyVector< K, T, C > const &b)
 ClassKeyVector >= ClassKeyVector. More...
 
bool operator== (Key const &a, Key const &b)
 Key == Key. More...
 
bool operator!= (Key const &a, Key const &b)
 Key != Key. More...
 
bool operator< (Key const &a, Key const &b)
 Key < Key. More...
 
bool operator<= (Key const &a, Key const &b)
 Key <= Key. More...
 
bool operator>= (Key const &a, Key const &b)
 Key >= Key. More...
 
bool operator> (Key const &a, Key const &b)
 Key > Key. More...
 
bool comparable (Key const &a, Key const &b)
 Are Keys of Comparable Types? More...
 
template<typename K1 , typename K2 >
bool operator== (Key2Tuple< K1, K2 > const &a, Key2Tuple< K1, K2 > const &b)
 Key2Tuple == Key2Tuple. More...
 
template<typename K1 , typename K2 >
bool operator!= (Key2Tuple< K1, K2 > const &a, Key2Tuple< K1, K2 > const &b)
 Key2Tuple != Key2Tuple. More...
 
template<typename K1 , typename K2 >
bool operator< (Key2Tuple< K1, K2 > const &a, Key2Tuple< K1, K2 > const &b)
 Key2Tuple < Key2Tuple. More...
 
template<typename K >
bool operator== (Key2Vector< K > const &a, Key2Vector< K > const &b)
 Key2Vector == Key2Vector. More...
 
template<typename K >
bool operator!= (Key2Vector< K > const &a, Key2Vector< K > const &b)
 Key2Vector != Key2Vector. More...
 
template<typename K >
bool operator< (Key2Vector< K > const &a, Key2Vector< K > const &b)
 Key2Vector < Key2Vector. More...
 
template<typename K1 , typename K2 , typename K3 >
bool operator== (Key3Tuple< K1, K2, K3 > const &a, Key3Tuple< K1, K2, K3 > const &b)
 Key3Tuple == Key3Tuple. More...
 
template<typename K1 , typename K2 , typename K3 >
bool operator!= (Key3Tuple< K1, K2, K3 > const &a, Key3Tuple< K1, K2, K3 > const &b)
 Key3Tuple != Key3Tuple. More...
 
template<typename K1 , typename K2 , typename K3 >
bool operator< (Key3Tuple< K1, K2, K3 > const &a, Key3Tuple< K1, K2, K3 > const &b)
 Key3Tuple < Key3Tuple. More...
 
template<typename K >
bool operator== (Key3Vector< K > const &a, Key3Vector< K > const &b)
 Key3Vector == Key3Vector. More...
 
template<typename K >
bool operator!= (Key3Vector< K > const &a, Key3Vector< K > const &b)
 Key3Vector != Key3Vector. More...
 
template<typename K >
bool operator< (Key3Vector< K > const &a, Key3Vector< K > const &b)
 Key3Vector < Key3Vector. More...
 
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. More...
 
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. More...
 
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. More...
 
template<typename K >
bool operator== (Key4Vector< K > const &a, Key4Vector< K > const &b)
 Key4Vector == Key4Vector. More...
 
template<typename K >
bool operator!= (Key4Vector< K > const &a, Key4Vector< K > const &b)
 Key4Vector != Key4Vector. More...
 
template<typename K >
bool operator< (Key4Vector< K > const &a, Key4Vector< K > const &b)
 Key4Vector < Key4Vector. More...
 
template<typename K , typename T >
void swap (KeyVector< K, T > &a, KeyVector< K, T > &b)
 swap( KeyVector, KeyVector ) More...
 
template<typename K , typename T >
bool operator== (KeyVector< K, T > const &a, KeyVector< K, T > const &b)
 KeyVector == KeyVector. More...
 
template<typename K , typename T >
bool operator!= (KeyVector< K, T > const &a, KeyVector< K, T > const &b)
 KeyVector != KeyVector. More...
 
template<typename K , typename T >
void swap (SmallKeyMap< K, T > &a, SmallKeyMap< K, T > &b)
 swap( SmallKeyMap, SmallKeyMap ) More...
 
template<typename K , typename T >
bool operator== (SmallKeyMap< K, T > const &a, SmallKeyMap< K, T > const &b)
 SmallKeyMap == SmallKeyMap. More...
 
template<typename K , typename T >
bool operator!= (SmallKeyMap< K, T > const &a, SmallKeyMap< K, T > const &b)
 SmallKeyMap != SmallKeyMap. More...
 
template<typename K , typename T >
void swap (SmallKeyVector< K, T > &a, SmallKeyVector< K, T > &b)
 swap( SmallKeyVector, SmallKeyVector ) More...
 
template<typename K , typename T >
bool operator== (SmallKeyVector< K, T > const &a, SmallKeyVector< K, T > const &b)
 SmallKeyVector == SmallKeyVector. More...
 
template<typename K , typename T >
bool operator!= (SmallKeyVector< K, T > const &a, SmallKeyVector< K, T > const &b)
 SmallKeyVector != SmallKeyVector. More...
 
template<typename O , typename S , typename C >
bool operator== (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey == UserKey. More...
 
template<typename O , typename S , typename C >
bool operator!= (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey != UserKey. More...
 
template<typename O , typename S , typename C >
bool operator< (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey < UserKey. More...
 
template<typename O , typename S , typename C >
bool operator<= (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey <= UserKey. More...
 
template<typename O , typename S , typename C >
bool operator>= (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey >= UserKey. More...
 
template<typename O , typename S , typename C >
bool operator> (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKey > UserKey. More...
 
template<typename O , typename S , typename C >
bool sequential (UserKey< O, S, C > const &a, UserKey< O, S, C > const &b)
 UserKeys are sequential? More...
 
template<typename K >
bool operator== (VariantKey< K > const &a, VariantKey< K > const &b)
 VariantKey == VariantKey. More...
 
template<typename K >
bool operator!= (VariantKey< K > const &a, VariantKey< K > const &b)
 VariantKey != VariantKey. More...
 
template<typename K >
bool operator< (VariantKey< K > const &a, VariantKey< K > const &b)
 VariantKey < VariantKey. More...
 

Function Documentation

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

Are Keys of Comparable Types?

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

template<typename K1 , typename K2 >
bool utility::keys::operator!= ( Key2Tuple< K1, K2 > const &  a,
Key2Tuple< K1, K2 > 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!= ( Key2Vector< K > const &  a,
Key2Vector< 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 >
bool utility::keys::operator!= ( Key3Vector< K > const &  a,
Key3Vector< K > const &  b 
)
template<typename K >
bool utility::keys::operator!= ( Key4Vector< K > const &  a,
Key4Vector< K > const &  b 
)
template<typename K >
bool utility::keys::operator!= ( VariantKey< K > const &  a,
VariantKey< 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 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 , 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!= ( KeyVector< K, T > const &  a,
KeyVector< K, T > 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 , typename T >
bool utility::keys::operator!= ( SmallKeyVector< K, T > const &  a,
SmallKeyVector< K, T > 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 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 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< ( 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 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 >
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 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
template<typename K >
bool utility::keys::operator< ( VariantKey< K > const &  a,
VariantKey< K > 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::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 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 
)
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 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 
)
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 >
bool utility::keys::operator== ( Key2Tuple< K1, K2 > const &  a,
Key2Tuple< K1, K2 > 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== ( Key2Vector< K > const &  a,
Key2Vector< 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 >
bool utility::keys::operator== ( Key3Vector< K > const &  a,
Key3Vector< K > const &  b 
)
template<typename K >
bool utility::keys::operator== ( Key4Vector< K > const &  a,
Key4Vector< K > const &  b 
)
template<typename K >
bool utility::keys::operator== ( VariantKey< K > const &  a,
VariantKey< 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 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 , 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== ( KeyVector< K, T > const &  a,
KeyVector< K, T > 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 , typename T >
bool utility::keys::operator== ( SmallKeyVector< K, T > const &  a,
SmallKeyVector< K, T > 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 
)
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
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 
)
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 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 
)
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::sequential ( UserKey< O, S, C > const &  a,
UserKey< O, S, C > const &  b 
)

UserKeys are sequential?

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?

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

swap( SmallKeyMap, SmallKeyMap )

References swap().

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

swap( KeyVector, KeyVector )

template<typename K , typename T , typename C >
void utility::keys::swap ( ClassKeyMap< K, T, C > &  a,
ClassKeyMap< K, T, C > &  b 
)

swap( ClassKeyMap, ClassKeyMap )

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

swap( SmallKeyVector, SmallKeyVector )

References swap().

template<typename K , typename T , typename C >
void utility::keys::swap ( ClassKeyVector< K, T, C > &  a,
ClassKeyVector< K, T, C > &  b 
)

swap( ClassKeyVector, ClassKeyVector )