Home

Libraries

Author

Links

---

dbmap.hpp

Go to the documentation of this file.

/* ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is the SysToMath DB C++ Libraries package (LibStmDb).
 *
 * The Initial Developer of the Original Code is
 * Tom Michaelis, SysToMath.
 * Portions created by the Initial Developer are Copyright (C) 2003-2008
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either the GNU General Public License Version 2 or later (the "GPL"), or
 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/******************************************************************************
 *                       First Release 2003-03-15
 ******************************************************************************/


#ifndef STM_DBMAP_HPP
#define STM_DBMAP_HPP


// Include header files and macros for implementation.
#include <stm/impl/dbxmap.hpp>


namespace stm
{


namespace db
{




typedef dword size_type;


typedef int32 difference_type;


typedef char char_type;


const size_type locking = 1;


template <class FlagsT, FlagsT Flags>
struct policy
{
    typedef FlagsT flags_type;
    typedef boost::mpl::bool_<(Flags & flags_type (locking)) == flags_type (locking)> lock;
};


template <size_type Flags>
struct default_policy : public policy<size_type, Flags>
{};


template <class SizeT, class DiffT, class CharT, class Allocator>
struct traits
{
    typedef SizeT size_type;
    typedef DiffT difference_type;
    typedef CharT char_type;
    typedef Allocator allocator_type;
    typedef std::basic_string
    <
        char_type,
        std::char_traits<char_type>,
        typename allocator_type::template rebind<char_type>::other
    >
    string_type;
};


template <class Allocator>
struct default_traits :
    public traits<size_type, difference_type, char_type, Allocator>
{};


struct null_type
{
    null_type ();
};


template <typename T> struct is_variant;


template <typename T> struct is_optional;


template <typename T> struct optional :
    public boost::variant<db::null_type, T>
{
    bool exists () const;
};


template <typename T> struct is_bytelike;


template <typename T, class Enable = void> struct may_endiancvt;


template <typename T, class Enable = void> struct is_conslist;


template <class Sequence, class Enable = void> struct conslist;


class buffer
{
public:
    virtual void append (const byte *src, size_type size) = 0;

    virtual const byte *extract (size_type size) = 0;

    virtual bool endiancvt () const = 0;

    template <typename T>
    buffer &operator<< (const T &value);

    template <typename T>
    buffer &operator>> (T &value);
};


template <typename T, class Enable = void>
struct stream
{
    static void put (buffer &buf, const T &value);

    static void get (buffer &buf, T &value);
};


template <typename T>
struct stream<T, typename boost::enable_if<boost::is_empty<T> >::type>;


template <typename T>
struct stream<T, typename boost::enable_if<boost::is_pod<T> >::type>;


template <typename T, class Allocator>
struct stream<std::vector<T, Allocator> >;
 

template <class charT, class traits, class Allocator>
struct stream<std::basic_string<charT, traits, Allocator> >;


template <class T>
struct stream<T, typename boost::enable_if<is_variant<T> >::type>;


template <class T>
struct stream<T, typename boost::enable_if<is_optional<T> >::type>;


template <class T>
struct stream<T, typename boost::enable_if<is_conslist<T> >::type>;


template <typename T1, typename T2>
struct stream<std::pair<T1, T2> >;
 

}}  // namespace stm::db


// Include base class implementation.
#include <stm/impl/dbxmap.hpp>


namespace stm
{


namespace db
{








//\{
template
<
    class Key,
    class T,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<std::pair<const Key, T> >,
    class Policy = default_policy<0>,
    class Traits = default_traits<Allocator>
>
class map :
    private local::pxmap<Key, T, Compare, Allocator, Policy, Traits, false>  // Implementation.
{
    typedef local::pxmap<Key, T, Compare, Allocator, Policy, Traits, false> proxy;  // Implementation

public:

    typedef map<Key, T, Compare, Allocator, Policy, Traits> db_type;

    typedef Key key_type;

    typedef T mapped_type;

    typedef std::pair<const Key, T> value_type;
    typedef Compare key_compare;
    typedef typename proxy::value_compare value_compare;
    typedef Allocator allocator_type;
    typedef Policy policy_type;
    typedef Traits traits_type;

    typedef typename Allocator::reference reference;
    typedef typename Allocator::const_reference const_reference;

    typedef typename Allocator::pointer pointer;
    typedef typename Allocator::const_pointer const_pointer;

    typedef typename proxy::iterator iterator;
    typedef typename proxy::const_iterator const_iterator;

    typedef typename proxy::reverse_iterator reverse_iterator;
    typedef typename proxy::const_reverse_iterator const_reverse_iterator;

    typedef typename traits_type::size_type size_type;
    typedef typename traits_type::difference_type difference_type;
    typedef typename traits_type::char_type char_type;
    typedef typename traits_type::string_type string_type;

    class locker;

    template
    <
        class SKey,
        class SCompare = std::less<SKey>
    > class index;

    typedef typename policy_type::flags_type flags_type;


    //\}////////////////////////////////////////////////////////////////////////

    static const flags_type noflags = proxy::noflags;

    static const flags_type truncate = proxy::truncate;

    static const flags_type forceendiancvt = proxy::forceendiancvt;

    static const flags_type multiprocessing = proxy::multiprocessing;


    //\}////////////////////////////////////////////////////////////////////////

    map ();

    explicit map
    (
        const string_type &name,
        flags_type flags = noflags,
        const key_compare &comp = key_compare (),
        const allocator_type &alloc = allocator_type ()
    );

    template <class InputIterator>
    map
    (
        InputIterator first,
        InputIterator last,
        const string_type &name = string_type (),
        flags_type flags = noflags,
        const key_compare &comp = key_compare (),
        const allocator_type &alloc = allocator_type ()
    );

    map
    (
        const map<Key, T, Compare, Allocator, Policy, Traits> &rhs,
        const string_type &name = string_type ()
    );

    map<Key, T, Compare, Allocator, Policy, Traits> &operator=
    (
        const map<Key, T, Compare, Allocator, Policy, Traits> &rhs
    );

    void swap (map<Key, T, Compare, Allocator, Policy, Traits> &other) throw ();

    ~map ();


    //\}////////////////////////////////////////////////////////////////////////

    iterator begin ();
    const_iterator begin () const;

    iterator end ();
    const_iterator end () const;

    reverse_iterator rbegin ();
    const_reverse_iterator rbegin () const;

    reverse_iterator rend ();
    const_reverse_iterator rend () const;


    //\}////////////////////////////////////////////////////////////////////////

    bool empty () const;
    size_type size () const;
    size_type max_size () const;


    //\}////////////////////////////////////////////////////////////////////////

    mapped_type &operator[] (const key_type &key);


    //\}////////////////////////////////////////////////////////////////////////

    iterator insert (iterator hint, const value_type &value);
    std::pair<typename db_type::iterator, bool> insert (const value_type &value);

    template <typename InputIterator>
    void insert (InputIterator first, InputIterator last);

    void erase (iterator position);
    size_type erase (const key_type &key);
    void erase (iterator first, iterator last);
    void clear ();


    //\}////////////////////////////////////////////////////////////////////////

    key_compare key_comp () const;
    value_compare value_comp () const;
    allocator_type get_allocator () const;

    bool endiancvt () const;

    flags_type get_flags () const;

    const string_type &get_name () const;


    //\}////////////////////////////////////////////////////////////////////////

    iterator find (const key_type &key);
    const_iterator find (const key_type &key) const;
    reverse_iterator rfind (const key_type &key);
    const_reverse_iterator rfind (const key_type &key) const;
    size_type count (const key_type &key) const;
    iterator lower_bound (const key_type &key);
    const_iterator lower_bound (const key_type &key) const;
    iterator upper_bound (const key_type &key);
    const_iterator upper_bound (const key_type &key) const;
    std::pair<iterator, iterator> equal_range (const key_type &key);
    std::pair<const_iterator, const_iterator> equal_range (const key_type &key) const;
};



//\{
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 map<Key, T, Compare, Allocator, Policy, Traits>::locker :
    private local::plocker<Key, T, Compare, Allocator, Policy, Traits, false, typename policy_type::lock>
{
public:
    // Type definitions.
    typedef map<Key, T, Compare, Allocator, Policy, Traits> db_type;
    typedef boost::function<void ()> cb_type;

    // Constructor.
    locker (const db_type &db, cb_type unlockfct = 0);

    // Constructor.
    template <class IndexT>
    locker (const IndexT &idx, cb_type unlockfct = 0);

    // Destructor.
    ~locker ();
};


template <class Key, class T, class Compare, class Allocator, class Policy, class Traits>
template <class SKey, class SCompare>
class map<Key, T, Compare, Allocator, Policy, Traits>::index :
    private local::pindex<Key, T, Compare, Allocator, Policy, Traits, SKey, SCompare>  // Implementation.
{
    typedef local::pindex<Key, T, Compare, Allocator, Policy, Traits, SKey, SCompare> proxy;  // Implementation.

public:
    // Type definitions.
    typedef map<Key, T, Compare, Allocator, Policy, Traits> db_type;
    typedef typename db_type::key_type key_type;
    typedef typename db_type::mapped_type mapped_type;
    typedef typename db_type::value_type value_type;
    typedef typename db_type::policy_type policy_type;
    typedef typename db_type::traits_type traits_type;
    typedef typename db_type::size_type size_type;
    typedef typename db_type::difference_type difference_type;
    typedef typename db_type::char_type char_type;
    typedef typename db_type::string_type string_type;
    typedef SKey skey_type;
    typedef SCompare skey_compare;
    typedef typename proxy::skeyfct_type skeyfct_type;

    typedef typename proxy::iterator iterator;
    typedef typename proxy::const_iterator const_iterator;

    typedef typename proxy::reverse_iterator reverse_iterator;
    typedef typename proxy::const_reverse_iterator const_reverse_iterator;

    typedef typename db_type::flags_type flags_type;

    // Flag value definitions (bitwise orable).
    static const flags_type noflags = proxy::noflags;
    static const flags_type reindex = proxy::reindex;

    // Construction and destruction.
    index ();

    explicit index
    (
        const db_type &db,
        const string_type &name
    );

    explicit index
    (
        const db_type &db,
        skeyfct_type skeyfct,
        const string_type &name = string_type (),
        flags_type flags = noflags,
        const skey_compare &comp = skey_compare ()
    );

    index
    (
        const index<SKey, SCompare> &rhs,
        const string_type &name = string_type ()
    );

    index<SKey, SCompare> &operator=
    (
        const index<SKey, SCompare> &rhs
    );

    void swap (index<SKey, SCompare> &other) throw ();

    ~index ();

    // Iterators.
    iterator begin ();
    const_iterator begin () const;

    iterator end ();
    const_iterator end () const;

    reverse_iterator rbegin ();
    const_reverse_iterator rbegin () const;

    reverse_iterator rend ();
    const_reverse_iterator rend () const;

    // Capacity.
    bool empty () const;
    size_type size () const;
    size_type max_size () const;

    // Modifiers.
    void erase (iterator position);
    size_type erase (const skey_type &skey);
    void erase (iterator first, iterator last);
    void clear ();

    // Observers.
    const db_type &dbmap () const;
    skey_compare skey_comp () const;
    skeyfct_type get_skeyfct () const;
    bool endiancvt () const;
    flags_type get_flags () const;
    const string_type &get_name () const;

    // db::map::index key operations.
    iterator find (const skey_type &skey);
    const_iterator find (const skey_type &skey) const;
    reverse_iterator rfind (const skey_type &skey);
    const_reverse_iterator rfind (const skey_type &skey) const;
    size_type count (const skey_type &skey) const;
    iterator lower_bound (const skey_type &skey);
    const_iterator lower_bound (const skey_type &skey) const;
    iterator upper_bound (const skey_type &skey);
    const_iterator upper_bound (const skey_type &skey) const;
    std::pair<iterator, iterator> equal_range (const skey_type &skey);
    std::pair<const_iterator, const_iterator> equal_range (const skey_type &skey) const;
};

    
// db::map::index comparison operators.
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);


// db::map::index specialized algorithms.
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 = std::less<Key>,
    class Allocator = std::allocator<Key>,
    class Policy = default_policy<0>,
    class Traits = default_traits<Allocator>
>
class set :
    private local::pxmap<Key, null_type, Compare, Allocator, Policy, Traits, false>  // Implementation.
{
    typedef local::pxmap<Key, null_type, Compare, Allocator, Policy, Traits, false> proxy;  // Implementation

public:

    typedef set<Key, Compare, Allocator, Policy, Traits> db_type;

    typedef Key key_type;

    typedef key_type value_type;
    typedef Compare key_compare;
    typedef Compare value_compare;
    typedef Allocator allocator_type;
    typedef Policy policy_type;
    typedef Traits traits_type;

    typedef typename Allocator::reference reference;
    typedef typename Allocator::const_reference const_reference;

    typedef typename Allocator::pointer pointer;
    typedef typename Allocator::const_pointer const_pointer;

    typedef typename proxy::iterator iterator;
    typedef typename proxy::const_iterator const_iterator;

    typedef typename proxy::reverse_iterator reverse_iterator;
    typedef typename proxy::const_reverse_iterator const_reverse_iterator;

    typedef typename traits_type::size_type size_type;
    typedef typename traits_type::difference_type difference_type;
    typedef typename traits_type::char_type char_type;
    typedef typename traits_type::string_type string_type;

    class locker;

    typedef typename policy_type::flags_type flags_type;


    //\}////////////////////////////////////////////////////////////////////////

    static const flags_type noflags = proxy::noflags;

    static const flags_type truncate = proxy::truncate;

    static const flags_type forceendiancvt = proxy::forceendiancvt;

    static const flags_type multiprocessing = proxy::multiprocessing;


    //\}////////////////////////////////////////////////////////////////////////

    set ();

    explicit set
    (
        const string_type &name,
        flags_type flags = noflags,
        const key_compare &comp = key_compare (),
        const allocator_type &alloc = allocator_type ()
    );

    template <class InputIterator>
    set
    (
        InputIterator first,
        InputIterator last,
        const string_type &name = string_type (),
        flags_type flags = noflags,
        const key_compare &comp = key_compare (),
        const allocator_type &alloc = allocator_type ()
    );

    set
    (
        const set<Key, Compare, Allocator, Policy, Traits> &rhs,
        const string_type &name = string_type ()
    );

    set<Key, Compare, Allocator, Policy, Traits> &operator=
    (
        const set<Key, Compare, Allocator, Policy, Traits> &rhs
    );

    void swap (set<Key, Compare, Allocator, Policy, Traits> &other) throw ();

    ~set ();


    //\}////////////////////////////////////////////////////////////////////////

    iterator begin ();
    const_iterator begin () const;

    iterator end ();
    const_iterator end () const;

    reverse_iterator rbegin ();
    const_reverse_iterator rbegin () const;

    reverse_iterator rend ();
    const_reverse_iterator rend () const;


    //\}////////////////////////////////////////////////////////////////////////

    bool empty () const;
    size_type size () const;
    size_type max_size () const;


    //\}////////////////////////////////////////////////////////////////////////

    iterator insert (iterator hint, const value_type &value);
    std::pair<typename db_type::iterator, bool> insert (const value_type &value);

    template <typename InputIterator>
    void insert (InputIterator first, InputIterator last);

    void erase (iterator position);
    size_type erase (const key_type &key);
    void erase (iterator first, iterator last);
    void clear ();


    //\}////////////////////////////////////////////////////////////////////////

    key_compare key_comp () const;
    value_compare value_comp () const;
    allocator_type get_allocator () const;

    bool endiancvt () const;

    flags_type get_flags () const;

    const string_type &get_name () const;


    //\}////////////////////////////////////////////////////////////////////////

    iterator find (const key_type &key);
    const_iterator find (const key_type &key) const;
    reverse_iterator rfind (const key_type &key);
    const_reverse_iterator rfind (const key_type &key) const;
    size_type count (const key_type &key) const;
    iterator lower_bound (const key_type &key);
    const_iterator lower_bound (const key_type &key) const;
    iterator upper_bound (const key_type &key);
    const_iterator upper_bound (const key_type &key) const;
    std::pair<iterator, iterator> equal_range (const key_type &key);
    std::pair<const_iterator, const_iterator> equal_range (const key_type &key) const;
};



//\{
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 Compare, class Allocator, class Policy, class Traits>
class set<Key, Compare, Allocator, Policy, Traits>::locker :
    private local::plocker<Key, null_type, Compare, Allocator, Policy, Traits, false, typename policy_type::lock>
{
public:
    // Type definitions.
    typedef set<Key, Compare, Allocator, Policy, Traits> db_type;
    typedef boost::function<void ()> cb_type;

    // Constructor.
    locker (const db_type &db, cb_type unlockfct = 0);

    // Constructor.
    template <class IndexT>
    locker (const IndexT &idx, cb_type unlockfct = 0);

    // Destructor.
    ~locker ();
};


template
<
    class Key,
    class T,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<std::pair<const Key, T> >,
    class Policy = default_policy<0>,
    class Traits = default_traits<Allocator>
>
class multimap :
    private local::pxmap<Key, T, Compare, Allocator, Policy, Traits, true>  // Implementation.
{
    typedef local::pxmap<Key, T, Compare, Allocator, Policy, Traits, true> proxy;  // Implementation

public:
    // Type definitions.
    typedef multimap<Key, T, Compare, Allocator, Policy, Traits> db_type;
    typedef Key key_type;
    typedef T mapped_type;
    typedef std::pair<const Key, T> value_type;
    typedef Compare key_compare;
    typedef typename proxy::value_compare value_compare;
    typedef Allocator allocator_type;
    typedef Policy policy_type;
    typedef Traits traits_type;

    typedef typename Allocator::reference reference;
    typedef typename Allocator::const_reference const_reference;

    typedef typename Allocator::pointer pointer;
    typedef typename Allocator::const_pointer const_pointer;

    typedef typename proxy::iterator iterator;
    typedef typename proxy::const_iterator const_iterator;

    typedef typename proxy::reverse_iterator reverse_iterator;
    typedef typename proxy::const_reverse_iterator const_reverse_iterator;

    typedef typename traits_type::size_type size_type;
    typedef typename traits_type::difference_type difference_type;
    typedef typename traits_type::char_type char_type;
    typedef typename traits_type::string_type string_type;

    class locker;

    typedef typename policy_type::flags_type flags_type;

    // Flag value definitions (bitwise orable).
    static const flags_type noflags = proxy::noflags;
    static const flags_type truncate = proxy::truncate;
    static const flags_type forceendiancvt = proxy::forceendiancvt;
    static const flags_type multiprocessing = proxy::multiprocessing;

    // Construction and destruction.
    multimap ();

    explicit multimap
    (
        const string_type &name = string_type (),
        flags_type flags = noflags,
        const key_compare &comp = key_compare (),
        const allocator_type &alloc = allocator_type ()
    );

    template <class InputIterator>
    multimap
    (
        InputIterator first,
        InputIterator last,
        const string_type &name = string_type (),
        flags_type flags = noflags,
        const key_compare &comp = key_compare (),
        const allocator_type &alloc = allocator_type ()
    );

    multimap
    (
        const multimap<Key, T, Compare, Allocator, Policy, Traits> &rhs,
        const string_type &name = string_type ()
    );

    multimap<Key, T, Compare, Allocator, Policy, Traits> &operator=
    (
        const multimap<Key, T, Compare, Allocator, Policy, Traits> &rhs
    );

    void swap (multimap<Key, T, Compare, Allocator, Policy, Traits> &other) throw ();

    ~multimap ();

    // Iterators.
    iterator begin ();
    const_iterator begin () const;

    iterator end ();
    const_iterator end () const;

    reverse_iterator rbegin ();
    const_reverse_iterator rbegin () const;

    reverse_iterator rend ();
    const_reverse_iterator rend () const;

    // Capacity.
    bool empty () const;
    size_type size () const;
    size_type max_size () const;

    // Modifiers.
    iterator insert (iterator hint, const value_type &value);
    iterator insert (const value_type &value);

    template <typename InputIterator>
    void insert (InputIterator first, InputIterator last);

    void erase (iterator position);
    size_type erase (const key_type &key);
    void erase (iterator first, iterator last);
    void clear ();

    // Observers.
    key_compare key_comp () const;
    value_compare value_comp () const;
    allocator_type get_allocator () const;
    bool endiancvt () const;
    flags_type get_flags () const;
    const string_type &get_name () const;

    // db::multimap key operations.
    iterator find (const key_type &key);
    const_iterator find (const key_type &key) const;
    reverse_iterator rfind (const key_type &key);
    const_reverse_iterator rfind (const key_type &key) const;
    size_type count (const key_type &key) const;
    iterator lower_bound (const key_type &key);
    const_iterator lower_bound (const key_type &key) const;
    iterator upper_bound (const key_type &key);
    const_iterator upper_bound (const key_type &key) const;
    std::pair<iterator, iterator> equal_range (const key_type &key);
    std::pair<const_iterator, const_iterator> equal_range (const key_type &key) const;
};


// db::multimap comparison operators.
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);


// db::multimap specialized algorithms.
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 T, class Compare, class Allocator, class Policy, class Traits>
class multimap<Key, T, Compare, Allocator, Policy, Traits>::locker :
    private local::plocker<Key, T, Compare, Allocator, Policy, Traits, true, typename policy_type::lock>
{
public:
    // Type definitions.
    typedef multimap<Key, T, Compare, Allocator, Policy, Traits> db_type;
    typedef boost::function<void ()> cb_type;

    // Constructor.
    locker (const db_type &db, cb_type unlockfct = 0);

    // Destructor.
    ~locker ();
};


template
<
    class Key,
    class Compare = std::less<Key>,
    class Allocator = std::allocator<Key>,
    class Policy = default_policy<0>,
    class Traits = default_traits<Allocator>
>
class multiset :
    private local::pxmap<Key, null_type, Compare, Allocator, Policy, Traits, true>  // Implementation.
{
    typedef local::pxmap<Key, null_type, Compare, Allocator, Policy, Traits, true> proxy;  // Implementation

public:
    // Type definitions.
    typedef multiset<Key, Compare, Allocator, Policy, Traits> db_type;
    typedef Key key_type;
    typedef key_type value_type;
    typedef Compare key_compare;
    typedef Compare value_compare;
    typedef Allocator allocator_type;
    typedef Policy policy_type;
    typedef Traits traits_type;

    typedef typename Allocator::reference reference;
    typedef typename Allocator::const_reference const_reference;

    typedef typename Allocator::pointer pointer;
    typedef typename Allocator::const_pointer const_pointer;

    typedef typename proxy::iterator iterator;
    typedef typename proxy::const_iterator const_iterator;

    typedef typename proxy::reverse_iterator reverse_iterator;
    typedef typename proxy::const_reverse_iterator const_reverse_iterator;

    typedef typename traits_type::size_type size_type;
    typedef typename traits_type::difference_type difference_type;
    typedef typename traits_type::char_type char_type;
    typedef typename traits_type::string_type string_type;

    class locker;

    typedef typename policy_type::flags_type flags_type;

    // Flag value definitions (bitwise orable).
    static const flags_type noflags = proxy::noflags;
    static const flags_type truncate = proxy::truncate;
    static const flags_type forceendiancvt = proxy::forceendiancvt;
    static const flags_type multiprocessing = proxy::multiprocessing;

    // Construction and destruction.
    multiset ();

    explicit multiset
    (
        const string_type &name = string_type (),
        flags_type flags = noflags,
        const key_compare &comp = key_compare (),
        const allocator_type &alloc = allocator_type ()
    );

    template <class InputIterator>
    multiset
    (
        InputIterator first,
        InputIterator last,
        const string_type &name = string_type (),
        flags_type flags = noflags,
        const key_compare &comp = key_compare (),
        const allocator_type &alloc = allocator_type ()
    );

    multiset
    (
        const multiset<Key, Compare, Allocator, Policy, Traits> &rhs,
        const string_type &name = string_type ()
    );

    multiset<Key, Compare, Allocator, Policy, Traits> &operator=
    (
        const multiset<Key, Compare, Allocator, Policy, Traits> &rhs
    );

    void swap (multiset<Key, Compare, Allocator, Policy, Traits> &other) throw ();

    ~multiset ();

    // Iterators.
    iterator begin ();
    const_iterator begin () const;

    iterator end ();
    const_iterator end () const;

    reverse_iterator rbegin ();
    const_reverse_iterator rbegin () const;

    reverse_iterator rend ();
    const_reverse_iterator rend () const;

    // Capacity.
    bool empty () const;
    size_type size () const;
    size_type max_size () const;

    // Modifiers.
    iterator insert (iterator hint, const value_type &value);
    iterator insert (const value_type &value);

    template <typename InputIterator>
    void insert (InputIterator first, InputIterator last);

    void erase (iterator position);
    size_type erase (const key_type &key);
    void erase (iterator first, iterator last);
    void clear ();

    // Observers.
    key_compare key_comp () const;
    value_compare value_comp () const;
    allocator_type get_allocator () const;
    bool endiancvt () const;
    flags_type get_flags () const;
    const string_type &get_name () const;

    // db::multiset key operations.
    iterator find (const key_type &key);
    const_iterator find (const key_type &key) const;
    reverse_iterator rfind (const key_type &key);
    const_reverse_iterator rfind (const key_type &key) const;
    size_type count (const key_type &key) const;
    iterator lower_bound (const key_type &key);
    const_iterator lower_bound (const key_type &key) const;
    iterator upper_bound (const key_type &key);
    const_iterator upper_bound (const key_type &key) const;
    std::pair<iterator, iterator> equal_range (const key_type &key);
    std::pair<const_iterator, const_iterator> equal_range (const key_type &key) const;
};


// db::multiset comparison operators.
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);


// db::multiset specialized algorithms.
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);


template <class Key, class Compare, class Allocator, class Policy, class Traits>
class multiset<Key, Compare, Allocator, Policy, Traits>::locker :
    private local::plocker<Key, null_type, Compare, Allocator, Policy, Traits, true, typename policy_type::lock>
{
public:
    // Type definitions.
    typedef multiset<Key, Compare, Allocator, Policy, Traits> db_type;
    typedef boost::function<void ()> cb_type;

    // Constructor.
    locker (const db_type &db, cb_type unlockfct = 0);

    // Destructor.
    ~locker ();
};


}  // namespace db


}  // namespace stm


// Include inline implementation.
#include <stm/impl/dbxmap.hpp>


#endif  // STM_DBMAP_HPP

---

© Copyright Tom Michaelis 2002-2007

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