Home Libraries Author Links

stm::db Namespace Reference


Detailed Description

Namespace db contains the associative container class templates db::map and db::set supporting unique keys and the associative container class templates db::multimap and db::multiset supporting equivalent keys.

They are modelled after the containers std::map, std::set, std::multimap and std::multiset as defined in the international standard C++ISO/IEC 14882:2003(E). Citations of this international standard used in this header file are parenthesized expressions with the same syntax and semantics as inside the international standard itself. The class templates db::map, db::set, db::multimap and db::multiset meet all associative container requirements (23.1.2) and additionally permit named persistent storage of their contents as their implemention is based on the Berkeley database engine. So by means of db::map, db::set, db::multimap and db::multiset iterators which meet all bidirectional iterator requirements (24.1.4), arbitrary big containers are effectively manageable. Moreover, the class template db::map provides a member class template index permitting quick sorted database access according to user definable secondary keys and sort criteria.


Classes

struct  policy
 Class template serving as Policy template parameter for class templates db::map, db::set, db::multimap and db::multiset. More...
struct  default_policy
 Default policy template parameter for class templates db::map, db::set, db::multimap and db::multiset. More...
struct  traits
 Class template serving as Traits template parameter for class templates db::map, db::set, db::multimap and db::multiset. More...
struct  default_traits
 Default traits template parameter for class templates db::map, db::set, db::multimap and db::multiset. More...
struct  null_type
 Empty type with default constructor doing nothing. More...
struct  optional
 The class template optional<T> is a boost::variant type consisting of a db::null_type member, if the instance holds no T value and a T member, if it holds a T value. More...
class  buffer
 The interface class buffer serves as a buffer abstraction for the conversion of application key and data objects into their byte serialzed form needed to store them in Berkeley databases and vice versa. More...
struct  stream
 The class template stream<T> on the first hand serves as stream type to append values of type T in a byte serialized form to the buffers used in the access imlementation of Berkeley databases and on the other hand to extract values of type T from those buffers. More...
class  map
 The db::map class template is a kind of associative container that supports unique keys (contains at most one of each key value) and provides for fast retrieval of values of another type T based on the keys. More...
class  set
 The db::set class template is a kind of associative container that supports unique keys (contains at most one of each key value) and provides for fast retrieval based on these keys. More...
class  multimap
 Class template db::multimap. More...
class  multiset
 Class template db::multiset. More...
struct  stream< Data >

Namespaces

namespace  sql

Typedefs

typedef dword size_type
 For now the Berkeley database engine supports only 32 bit sizes.
typedef int32 difference_type
 For now the Berkeley database engine supports only 32 bit sizes.
typedef char char_type
 For now only plain char characters are supported.

Functions

template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator== (const map< Key, T, Compare, Allocator, Policy, Traits > &x, const map< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator< (const map< Key, T, Compare, Allocator, Policy, Traits > &x, const map< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator!= (const map< Key, T, Compare, Allocator, Policy, Traits > &x, const map< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator> (const map< Key, T, Compare, Allocator, Policy, Traits > &x, const map< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator>= (const map< Key, T, Compare, Allocator, Policy, Traits > &x, const map< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator<= (const map< Key, T, Compare, Allocator, Policy, Traits > &x, const map< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
void swap (map< Key, T, Compare, Allocator, Policy, Traits > &x, map< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits, class SKey, class SCompare>
bool operator== (const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &x, const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits, class SKey, class SCompare>
bool operator< (const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &x, const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits, class SKey, class SCompare>
bool operator!= (const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &x, const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits, class SKey, class SCompare>
bool operator> (const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &x, const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits, class SKey, class SCompare>
bool operator>= (const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &x, const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits, class SKey, class SCompare>
bool operator<= (const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &x, const typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits, class SKey, class SCompare>
void swap (typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &x, typename map< Key, T, Compare, Allocator, Policy, Traits >::template index< SKey, SCompare > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator== (const set< Key, Compare, Allocator, Policy, Traits > &x, const set< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator< (const set< Key, Compare, Allocator, Policy, Traits > &x, const set< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator!= (const set< Key, Compare, Allocator, Policy, Traits > &x, const set< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator> (const set< Key, Compare, Allocator, Policy, Traits > &x, const set< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator>= (const set< Key, Compare, Allocator, Policy, Traits > &x, const set< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator<= (const set< Key, Compare, Allocator, Policy, Traits > &x, const set< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
void swap (set< Key, Compare, Allocator, Policy, Traits > &x, set< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator== (const multimap< Key, T, Compare, Allocator, Policy, Traits > &x, const multimap< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator< (const multimap< Key, T, Compare, Allocator, Policy, Traits > &x, const multimap< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator!= (const multimap< Key, T, Compare, Allocator, Policy, Traits > &x, const multimap< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator> (const multimap< Key, T, Compare, Allocator, Policy, Traits > &x, const multimap< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator>= (const multimap< Key, T, Compare, Allocator, Policy, Traits > &x, const multimap< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
bool operator<= (const multimap< Key, T, Compare, Allocator, Policy, Traits > &x, const multimap< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class T, class Compare, class Allocator, class Policy, class Traits>
void swap (multimap< Key, T, Compare, Allocator, Policy, Traits > &x, multimap< Key, T, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator== (const multiset< Key, Compare, Allocator, Policy, Traits > &x, const multiset< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator< (const multiset< Key, Compare, Allocator, Policy, Traits > &x, const multiset< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator!= (const multiset< Key, Compare, Allocator, Policy, Traits > &x, const multiset< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator> (const multiset< Key, Compare, Allocator, Policy, Traits > &x, const multiset< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator>= (const multiset< Key, Compare, Allocator, Policy, Traits > &x, const multiset< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
bool operator<= (const multiset< Key, Compare, Allocator, Policy, Traits > &x, const multiset< Key, Compare, Allocator, Policy, Traits > &y)
template<class Key, class Compare, class Allocator, class Policy, class Traits>
void swap (multiset< Key, Compare, Allocator, Policy, Traits > &x, multiset< Key, Compare, Allocator, Policy, Traits > &y)

Variables

const size_type locking = 1
 Policy flags (bitwise orable).


© Copyright Tom Michaelis 2002-2007

Distributed under the SysToMath Software License (See the accompanying file license.txt or a copy at www.SysToMath.com).