vector.h

Go to the documentation of this file.

/***************************************************************************
 *  include/stxxl/bits/containers/vector.h
 *
 *  Part of the STXXL. See http://stxxl.sourceforge.net
 *
 *  Copyright (C) 2002-2008 Roman Dementiev <[email protected]>
 *  Copyright (C) 2007-2009 Johannes Singler <[email protected]>
 *  Copyright (C) 2008-2010 Andreas Beckmann <[email protected]>
 *  Copyright (C) 2013 Timo Bingmann <[email protected]>
 *
 *  Distributed under the Boost Software License, Version 1.0.
 *  (See accompanying file LICENSE_1_0.txt or copy at
 *  http://www.boost.org/LICENSE_1_0.txt)
 **************************************************************************/

#ifndef STXXL_CONTAINERS_VECTOR_HEADER
#define STXXL_CONTAINERS_VECTOR_HEADER

#include <vector>
#include <queue>
#include <algorithm>

#include <stxxl/bits/deprecated.h>
#include <stxxl/bits/io/request_operations.h>
#include <stxxl/bits/mng/block_manager.h>
#include <stxxl/bits/mng/typed_block.h>
#include <stxxl/bits/common/tmeta.h>
#include <stxxl/bits/containers/pager.h>
#include <stxxl/bits/common/is_sorted.h>
#include <stxxl/bits/mng/buf_istream.h>
#include <stxxl/bits/mng/buf_istream_reverse.h>
#include <stxxl/bits/mng/buf_ostream.h>


STXXL_BEGIN_NAMESPACE

#define STXXL_VERBOSE_VECTOR(msg) STXXL_VERBOSE1("vector[" << static_cast<const void*>(this) << "]::" << msg)

//! \defgroup stlcont Containers
//! \ingroup stllayer
//! Containers with STL-compatible interface


//! \defgroup stlcont_vector vector
//! \ingroup stlcont
//! Vector and support classes
//! \{

template <typename size_type, size_type modulo2, size_type modulo1>
class double_blocked_index
{
    static const size_type modulo12 = modulo1 * modulo2;

    size_type pos;
    unsigned_type block1, block2, offset;

    //! \invariant block2 * modulo12 + block1 * modulo1 + offset == pos && 0 <= block1 &lt; modulo2 && 0 <= offset &lt; modulo1

    void set(size_type pos)
    {
        this->pos = pos;
        block2 = (int_type)(pos / modulo12);
        pos -= block2 * modulo12;
        block1 = (int_type)(pos / modulo1);
        offset = (int_type)(pos - block1 * modulo1);

        assert(block2 * modulo12 + block1 * modulo1 + offset == this->pos);
        assert(/* 0 <= block1 && */ block1 < modulo2);
        assert(/* 0 <= offset && */ offset < modulo1);
    }

public:
    double_blocked_index()
    {
        set(0);
    }

    double_blocked_index(size_type pos)
    {
        set(pos);
    }

    double_blocked_index(unsigned_type block2, unsigned_type block1, unsigned_type offset)
    {
        assert(/* 0 <= block1 && */ block1 < modulo2);
        assert(/* 0 <= offset && */ offset < modulo1);

        this->block2 = block2;
        this->block1 = block1;
        this->offset = offset;
        pos = block2 * modulo12 + block1 * modulo1 + offset;
    }

    double_blocked_index& operator = (size_type pos)
    {
        set(pos);
        return *this;
    }

    //pre-increment operator
    double_blocked_index& operator ++ ()
    {
        ++pos;
        ++offset;
        if (offset == modulo1)
        {
            offset = 0;
            ++block1;
            if (block1 == modulo2)
            {
                block1 = 0;
                ++block2;
            }
        }

        assert(block2 * modulo12 + block1 * modulo1 + offset == this->pos);
        assert(/* 0 <= block1 && */ block1 < modulo2);
        assert(/* 0 <= offset && */ offset < modulo1);

        return *this;
    }

    //post-increment operator
    double_blocked_index operator ++ (int)
    {
        double_blocked_index former(*this);
        operator ++ ();
        return former;
    }

    //pre-increment operator
    double_blocked_index& operator -- ()
    {
        --pos;
        if (offset == 0)
        {
            offset = modulo1;
            if (block1 == 0)
            {
                block1 = modulo2;
                --block2;
            }
            --block1;
        }
        --offset;

        assert(block2 * modulo12 + block1 * modulo1 + offset == this->pos);
        assert(/*0 <= block1 &&*/ block1 < modulo2);
        assert(/*0 <= offset &&*/ offset < modulo1);

        return *this;
    }

    //post-increment operator
    double_blocked_index operator -- (int)
    {
        double_blocked_index former(*this);
        operator -- ();
        return former;
    }

    double_blocked_index operator + (size_type addend) const
    {
        return double_blocked_index(pos + addend);
    }

    double_blocked_index& operator += (size_type addend)
    {
        set(pos + addend);
        return *this;
    }

    double_blocked_index operator - (size_type addend) const
    {
        return double_blocked_index(pos - addend);
    }

    size_type operator - (const double_blocked_index& dbi2) const
    {
        return pos - dbi2.pos;
    }

    double_blocked_index& operator -= (size_type subtrahend)
    {
        set(pos - subtrahend);
        return *this;
    }

    bool operator == (const double_blocked_index& dbi2) const
    {
        return pos == dbi2.pos;
    }

    bool operator != (const double_blocked_index& dbi2) const
    {
        return pos != dbi2.pos;
    }

    bool operator < (const double_blocked_index& dbi2) const
    {
        return pos < dbi2.pos;
    }

    bool operator <= (const double_blocked_index& dbi2) const
    {
        return pos <= dbi2.pos;
    }

    bool operator > (const double_blocked_index& dbi2) const
    {
        return pos > dbi2.pos;
    }

    bool operator >= (const double_blocked_index& dbi2) const
    {
        return pos >= dbi2.pos;
    }

    double_blocked_index& operator >>= (size_type shift)
    {
        set(pos >> shift);
        return *this;
    }

    size_type get_pos() const
    {
        return pos;
    }

    const unsigned_type & get_block2() const
    {
        return block2;
    }

    const unsigned_type & get_block1() const
    {
        return block1;
    }

    const unsigned_type & get_offset() const
    {
        return offset;
    }
};

////////////////////////////////////////////////////////////////////////////

template <
    typename ValueType,
    unsigned PageSize,
    typename PagerType,
    unsigned BlockSize,
    typename AllocStr,
    typename SizeType>
class vector;

template <typename ValueType, typename AllocStr, typename SizeType, typename DiffType,
          unsigned BlockSize, typename PagerType, unsigned PageSize>
class const_vector_iterator;

template <typename VectorIteratorType>
class vector_bufreader;

template <typename VectorIteratorType>
class vector_bufreader_reverse;

template <typename VectorIteratorType>
class vector_bufwriter;

////////////////////////////////////////////////////////////////////////////

//! External vector iterator, model of \c ext_random_access_iterator concept.
template <typename ValueType, typename AllocStr, typename SizeType, typename DiffType,
          unsigned BlockSize, typename PagerType, unsigned PageSize>
class vector_iterator
{
    typedef vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize> self_type;
    typedef const_vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize> const_self_type;

    friend class const_vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize>;

public:
    //! \name Types
    //! \{

    typedef self_type iterator;
    typedef const_self_type const_iterator;

    typedef unsigned block_offset_type;
    typedef vector<ValueType, PageSize, PagerType, BlockSize, AllocStr, SizeType> vector_type;
    friend class vector<ValueType, PageSize, PagerType, BlockSize, AllocStr, SizeType>;
    typedef typename vector_type::bids_container_type bids_container_type;
    typedef typename bids_container_type::iterator bids_container_iterator;
    typedef typename bids_container_type::bid_type bid_type;
    typedef typename vector_type::block_type block_type;
    typedef typename vector_type::blocked_index_type blocked_index_type;

    typedef std::random_access_iterator_tag iterator_category;
    typedef typename vector_type::size_type size_type;
    typedef typename vector_type::difference_type difference_type;
    typedef typename vector_type::value_type value_type;
    typedef typename vector_type::reference reference;
    typedef typename vector_type::const_reference const_reference;
    typedef typename vector_type::pointer pointer;
    typedef typename vector_type::const_pointer const_pointer;

    //! \}

protected:
    blocked_index_type offset;
    vector_type* p_vector;

private:
    //! private constructor for initializing other iterators
    vector_iterator(vector_type* v, size_type o)
        : offset(o), p_vector(v)
    { }

public:
    //! constructs invalid iterator
    vector_iterator()
        : offset(0), p_vector(NULL)
    { }
    //! copy-constructor
    vector_iterator(const self_type& a)
        : offset(a.offset),
          p_vector(a.p_vector)
    { }

    //! \name Iterator Properties
    //! \{

    //! return pointer to vector containing iterator
    vector_type * parent_vector() const
    {
        return p_vector;
    }
    //! return block offset of current element
    block_offset_type block_offset() const
    {
        return static_cast<block_offset_type>(offset.get_offset());
    }
    //! return iterator to BID containg current element
    bids_container_iterator bid() const
    {
        return p_vector->bid(offset);
    }

    //! \}

    //! \name Access Operators
    //! \{

    //! return current element
    reference operator * ()
    {
        return p_vector->element(offset);
    }
    //! return pointer to current element
    pointer operator -> ()
    {
        return &(p_vector->element(offset));
    }
    //! return const reference to current element
    const_reference operator * () const
    {
        return p_vector->const_element(offset);
    }
    //! return const pointer to current element
    const_pointer operator -> () const
    {
        return &(p_vector->const_element(offset));
    }
    //! return mutable reference to element +i after the current element
    reference operator [] (size_type i)
    {
        return p_vector->element(offset.get_pos() + i);
    }

#ifdef _LIBCPP_VERSION
    //-tb 2013-11: libc++ defines std::reverse_iterator::operator[] in such a
    // way that it expects vector_iterator::operator[] to return a (mutable)
    // reference. Thus to remove confusion about the compiler error, we remove
    // the operator[] const for libc++. The const_reference actually violates
    // some version of the STL standard, but works well in gcc's libstdc++.
#else
    //! return const reference to element +i after the current element
    const_reference operator [] (size_type i) const
    {
        return p_vector->const_element(offset.get_pos() + i);
    }
#endif
    //! \}

    //! \name Relative Calculation of Iterators
    //! \{

    //! calculate different between two iterator
    difference_type operator - (const self_type& a) const
    {
        return offset - a.offset;
    }
    //! calculate different between two iterator
    difference_type operator - (const const_self_type& a) const
    {
        return offset - a.offset;
    }
    //! return iterator advanced -i positions in the vector
    self_type operator - (size_type i) const
    {
        return self_type(p_vector, offset.get_pos() - i);
    }
    //! return iterator advanced +i positions in the vector
    self_type operator + (size_type i) const
    {
        return self_type(p_vector, offset.get_pos() + i);
    }
    //! advance this iterator -i positions in the vector
    self_type& operator -= (size_type i)
    {
        offset -= i;
        return *this;
    }
    //! advance this iterator +i positions in the vector
    self_type& operator += (size_type i)
    {
        offset += i;
        return *this;
    }
    //! advance this iterator to next position in the vector
    self_type& operator ++ ()
    {
        offset++;
        return *this;
    }
    //! advance this iterator to next position in the vector
    self_type operator ++ (int)
    {
        self_type tmp = *this;
        offset++;
        return tmp;
    }
    //! advance this iterator to preceding position in the vector
    self_type& operator -- ()
    {
        offset--;
        return *this;
    }
    //! advance this iterator to preceding position in the vector
    self_type operator -- (int)
    {
        self_type tmp = *this;
        offset--;
        return tmp;
    }

    //! \}

    //! \name Comparison Operators
    //! \{

    bool operator == (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset == a.offset;
    }
    bool operator != (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset != a.offset;
    }
    bool operator < (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset < a.offset;
    }
    bool operator <= (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset <= a.offset;
    }
    bool operator > (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset > a.offset;
    }
    bool operator >= (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset >= a.offset;
    }

    bool operator == (const const_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset == a.offset;
    }
    bool operator != (const const_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset != a.offset;
    }
    bool operator < (const const_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset < a.offset;
    }
    bool operator <= (const const_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset <= a.offset;
    }
    bool operator > (const const_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset > a.offset;
    }
    bool operator >= (const const_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset >= a.offset;
    }

    //! \}

    //! \name Flushing Operation
    //! \{

    void block_externally_updated()
    {
        p_vector->block_externally_updated(offset);
    }

    void flush()
    {
        p_vector->flush();
    }

    //! \}
};

////////////////////////////////////////////////////////////////////////////

//! Const external vector iterator, model of \c ext_random_access_iterator concept.
template <typename ValueType, typename AllocStr, typename SizeType, typename DiffType,
          unsigned BlockSize, typename PagerType, unsigned PageSize>
class const_vector_iterator
{
    typedef const_vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize> self_type;
    typedef vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize> mutable_self_type;

    friend class vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize>;

public:
    //! \name Types
    //! \{

    typedef self_type const_iterator;
    typedef mutable_self_type iterator;

    typedef unsigned block_offset_type;
    typedef vector<ValueType, PageSize, PagerType, BlockSize, AllocStr, SizeType> vector_type;
    friend class vector<ValueType, PageSize, PagerType, BlockSize, AllocStr, SizeType>;
    typedef typename vector_type::bids_container_type bids_container_type;
    typedef typename bids_container_type::iterator bids_container_iterator;
    typedef typename bids_container_type::bid_type bid_type;
    typedef typename vector_type::block_type block_type;
    typedef typename vector_type::blocked_index_type blocked_index_type;

    typedef std::random_access_iterator_tag iterator_category;
    typedef typename vector_type::size_type size_type;
    typedef typename vector_type::difference_type difference_type;
    typedef typename vector_type::value_type value_type;
    typedef typename vector_type::const_reference reference;
    typedef typename vector_type::const_reference const_reference;
    typedef typename vector_type::const_pointer pointer;
    typedef typename vector_type::const_pointer const_pointer;

    //! \}

protected:
    blocked_index_type offset;
    const vector_type* p_vector;

private:
    //! private constructor for initializing other iterators
    const_vector_iterator(const vector_type* v, size_type o)
        : offset(o), p_vector(v)
    { }

public:
    //! constructs invalid iterator
    const_vector_iterator()
        : offset(0), p_vector(NULL)
    { }
    //! copy-constructor
    const_vector_iterator(const self_type& a)
        : offset(a.offset), p_vector(a.p_vector)
    { }
    //! copy-constructor from mutable iterator
    const_vector_iterator(const mutable_self_type& a)
        : offset(a.offset), p_vector(a.p_vector)
    { }

    //! \name Iterator Properties
    //! \{

    //! return pointer to vector containing iterator
    const vector_type * parent_vector() const
    {
        return p_vector;
    }
    //! return block offset of current element
    block_offset_type block_offset() const
    {
        return static_cast<block_offset_type>(offset.get_offset());
    }
    //! return iterator to BID containg current element
    bids_container_iterator bid() const
    {
        return ((vector_type*)p_vector)->bid(offset);
    }

    //! \}

    //! \name Access Operators
    //! \{

    //! return current element
    const_reference operator * () const
    {
        return p_vector->const_element(offset);
    }
    //! return pointer to current element
    const_pointer operator -> () const
    {
        return &(p_vector->const_element(offset));
    }
    //! return const reference to element +i after the current element
    const_reference operator [] (size_type i) const
    {
        return p_vector->const_element(offset.get_pos() + i);
    }

    //! \}

    //! \name Relative Calculation of Iterators
    //! \{

    //! calculate different between two iterator
    difference_type operator - (const self_type& a) const
    {
        return offset - a.offset;
    }
    //! calculate different between two iterator
    difference_type operator - (const mutable_self_type& a) const
    {
        return offset - a.offset;
    }
    //! return iterator advanced -i positions in the vector
    self_type operator - (size_type i) const
    {
        return self_type(p_vector, offset.get_pos() - i);
    }
    //! return iterator advanced +i positions in the vector
    self_type operator + (size_type i) const
    {
        return self_type(p_vector, offset.get_pos() + i);
    }
    //! advance this iterator -i positions in the vector
    self_type& operator -= (size_type i)
    {
        offset -= i;
        return *this;
    }
    //! advance this iterator +i positions in the vector
    self_type& operator += (size_type i)
    {
        offset += i;
        return *this;
    }
    //! advance this iterator to next position in the vector
    self_type& operator ++ ()
    {
        offset++;
        return *this;
    }
    //! advance this iterator to next position in the vector
    self_type operator ++ (int)
    {
        self_type tmp_ = *this;
        offset++;
        return tmp_;
    }
    //! advance this iterator to preceding position in the vector
    self_type& operator -- ()
    {
        offset--;
        return *this;
    }
    //! advance this iterator to preceding position in the vector
    self_type operator -- (int)
    {
        self_type tmp = *this;
        offset--;
        return tmp;
    }

    //! \}

    //! \name Comparison Operators
    //! \{

    bool operator == (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset == a.offset;
    }
    bool operator != (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset != a.offset;
    }
    bool operator < (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset < a.offset;
    }
    bool operator <= (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset <= a.offset;
    }
    bool operator > (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset > a.offset;
    }
    bool operator >= (const self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset >= a.offset;
    }

    bool operator == (const mutable_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset == a.offset;
    }
    bool operator != (const mutable_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset != a.offset;
    }
    bool operator < (const mutable_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset < a.offset;
    }
    bool operator <= (const mutable_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset <= a.offset;
    }
    bool operator > (const mutable_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset > a.offset;
    }
    bool operator >= (const mutable_self_type& a) const
    {
        assert(p_vector == a.p_vector);
        return offset >= a.offset;
    }

    //! \}

    //! \name Flushing Operation
    //! \{

    void block_externally_updated()
    {
        p_vector->block_externally_updated(offset);
    }

    void flush()
    {
        p_vector->flush();
    }

    //! \}
};

////////////////////////////////////////////////////////////////////////////

//! \brief External vector container. \n
//! <b>Introduction</b> to vector container: see \ref tutorial_vector tutorial. \n
//! <b>Design and Internals</b> of vector container: see \ref design_vector
//!
//! For semantics of the methods see documentation of the STL std::vector
//! \tparam ValueType type of contained objects (POD with no references to internal memory)
//! \tparam PageSize number of blocks in a page
//! \tparam PagerType pager type, \c random_pager<x> or \c lru_pager<x>, where x is the default number of pages,
//!  default is \c lru_pager<8>
//! \tparam BlockSize external block size in bytes, default is 2 MiB
//! \tparam AllocStr one of allocation strategies: \c striping , \c RC , \c SR , or \c FR
//!  default is RC
//!
//! Memory consumption: BlockSize*x*PageSize bytes
//! \warning Do not store references to the elements of an external vector. Such references
//! might be invalidated during any following access to elements of the vector
template <
    typename ValueType,
    unsigned PageSize = 4,
    typename PagerType = lru_pager<8>,
    unsigned BlockSize = STXXL_DEFAULT_BLOCK_SIZE(ValueType),
    typename AllocStr = STXXL_DEFAULT_ALLOC_STRATEGY,
    typename SizeType = stxxl::uint64       // will be deprecated soon
    >
class vector
{
public:
    //! \name Standard Types
    //! \{

    //! The type of elements stored in the vector.
    typedef ValueType value_type;
    //! reference to value_type
    typedef value_type& reference;
    //! constant reference to value_type
    typedef const value_type& const_reference;
    //! pointer to value_type
    typedef value_type* pointer;
    //! constant pointer to value_type
    typedef const value_type* const_pointer;
    //! an unsigned 64-bit integral type
    typedef SizeType size_type;
    typedef stxxl::int64 difference_type;

    typedef PagerType pager_type;
    typedef AllocStr alloc_strategy_type;

    enum constants {
        block_size = BlockSize,
        page_size = PageSize,
        on_disk = -1
    };

    //! iterator used to iterate through a vector, see \ref design_vector_notes.
    typedef vector_iterator<value_type, alloc_strategy_type, size_type,
                            difference_type, block_size, pager_type, page_size> iterator;
    friend class vector_iterator<value_type, alloc_strategy_type, size_type, difference_type, block_size, pager_type, page_size>;

    //! constant iterator used to iterate through a vector, see \ref design_vector_notes.
    typedef const_vector_iterator<value_type, alloc_strategy_type,
                                  size_type, difference_type, block_size, pager_type, page_size> const_iterator;
    friend class const_vector_iterator<value_type, alloc_strategy_type, size_type, difference_type, block_size, pager_type, page_size>;
    typedef std::reverse_iterator<iterator> reverse_iterator;
    typedef std::reverse_iterator<const_iterator> const_reverse_iterator;

    //! \}

    //! \name Extra Types
    //! \{

    //! vector_bufwriter compatible with this vector
    typedef vector_bufwriter<iterator> bufwriter_type;

    //! vector_bufreader compatible with this vector
    typedef vector_bufreader<const_iterator> bufreader_type;

    //! vector_bufreader compatible with this vector
    typedef vector_bufreader_reverse<const_iterator> bufreader_reverse_type;

    //! \internal
    class bid_vector : public std::vector<BID<block_size> >
    {
    public:
        typedef std::vector<BID<block_size> > super_type;
        typedef typename super_type::size_type size_type;
        typedef typename super_type::value_type bid_type;

        bid_vector(size_type sz) : super_type(sz)
        { }
    };

    typedef bid_vector bids_container_type;
    typedef typename bids_container_type::iterator bids_container_iterator;
    typedef typename bids_container_type::const_iterator const_bids_container_iterator;

    //! type of the block used in disk-memory transfers
    typedef typed_block<BlockSize, ValueType> block_type;
    //! double-index type to reference individual elements in a block
    typedef double_blocked_index<SizeType, PageSize, block_type::size> blocked_index_type;

    //! \}

private:
    alloc_strategy_type m_alloc_strategy;
    size_type m_size;
    bids_container_type m_bids;
    mutable pager_type m_pager;

    // enum specifying status of a page of the vector
    enum { valid_on_disk = 0, uninitialized = 1, dirty = 2 };
    //! status of each page (valid_on_disk, uninitialized or dirty)
    mutable std::vector<unsigned char> m_page_status;
    mutable std::vector<int_type> m_page_to_slot;
    mutable simple_vector<int_type> m_slot_to_page;
    mutable std::queue<int_type> m_free_slots;
    mutable simple_vector<block_type>* m_cache;
    file* m_from;
    block_manager* m_bm;
    bool m_exported;

    size_type size_from_file_length(stxxl::uint64 file_length) const
    {
        stxxl::uint64 blocks_fit = file_length / stxxl::uint64(block_type::raw_size);
        size_type cur_size = blocks_fit * stxxl::uint64(block_type::size);
        stxxl::uint64 rest = file_length - blocks_fit * stxxl::uint64(block_type::raw_size);
        return (cur_size + rest / stxxl::uint64(sizeof(value_type)));
    }

    stxxl::uint64 file_length() const
    {
        typedef stxxl::uint64 file_size_type;
        size_type cur_size = size();
        size_type num_full_blocks = cur_size / block_type::size;
        if (cur_size % block_type::size != 0)
        {
            size_type rest = cur_size - num_full_blocks * block_type::size;
            return file_size_type(num_full_blocks) * block_type::raw_size + rest * sizeof(value_type);
        }
        return file_size_type(num_full_blocks) * block_type::raw_size;
    }

public:
    //! \name Constructors/Destructors
    //! \{

    //! Constructs external vector with n elements.
    //!
    //! \param n Number of elements.
    //! \param npages Number of cached pages.
    vector(size_type n = 0, unsigned_type npages = pager_type().size())
        : m_size(n),
          m_bids((size_t)div_ceil(n, block_type::size)),
          m_pager(npages),
          m_page_status(div_ceil(m_bids.size(), page_size)),
          m_page_to_slot(div_ceil(m_bids.size(), page_size)),
          m_slot_to_page(npages),
          m_cache(NULL),
          m_from(NULL),
          m_exported(false)
    {
        m_bm = block_manager::get_instance();

        allocate_page_cache();

        for (size_t i = 0; i < m_page_status.size(); ++i)
        {
            m_page_status[i] = uninitialized;
            m_page_to_slot[i] = on_disk;
        }

        for (unsigned_type i = 0; i < numpages(); ++i)
            m_free_slots.push(i);

        m_bm->new_blocks(m_alloc_strategy, m_bids.begin(), m_bids.end(), 0);
    }

    //! \}

    //! \name Modifier
    //! \{

    //! swap content
    void swap(vector& obj)
    {
        std::swap(m_alloc_strategy, obj.m_alloc_strategy);
        std::swap(m_size, obj.m_size);
        std::swap(m_bids, obj.m_bids);
        std::swap(m_pager, obj.m_pager);
        std::swap(m_page_status, obj.m_page_status);
        std::swap(m_page_to_slot, obj.m_page_to_slot);
        std::swap(m_slot_to_page, obj.m_slot_to_page);
        std::swap(m_free_slots, obj.m_free_slots);
        std::swap(m_cache, obj.m_cache);
        std::swap(m_from, obj.m_from);
        std::swap(m_exported, obj.m_exported);
    }

    //! \}

    //! \name Miscellaneous
    //! \{

    //! Allocate page cache, must be called to allow access to elements.
    void allocate_page_cache() const
    {
        //  numpages() might be zero
        if (!m_cache && numpages() > 0)
            m_cache = new simple_vector<block_type>(numpages() * page_size);
    }

    //! allows to free the cache, but you may not access any element until call
    //! allocate_page_cache() again
    void deallocate_page_cache() const
    {
        flush();
        delete m_cache;
        m_cache = NULL;
    }

    //! \name Size and Capacity
    //! \{

    //! return the size of the vector.
    size_type size() const
    {
        return m_size;
    }
    //! true if the vector's size is zero.
    bool empty() const
    {
        return (!m_size);
    }

    //! Return the number of elelemtsn for which \a external memory has been
    //! allocated. capacity() is always greator than or equal to size().
    size_type capacity() const
    {
        return size_type(m_bids.size()) * block_type::size;
    }
    //! Returns the number of bytes that the vector has allocated on disks.
    size_type raw_capacity() const
    {
        return size_type(m_bids.size()) * block_type::raw_size;
    }

    /*! \brief Reserves at least n elements in external memory.
     *
     * If n is less than or equal to capacity(), this call has no
     * effect. Otherwise, it is a request for allocation of additional \b
     * external memory. If the request is successful, then capacity() is
     * greater than or equal to n; otherwise capacity() is unchanged. In either
     * case, size() is unchanged.
     */
    void reserve(size_type n)
    {
        if (n <= capacity())
            return;

        unsigned_type old_bids_size = m_bids.size();
        unsigned_type new_bids_size = (unsigned_type)div_ceil(n, block_type::size);
        unsigned_type new_pages = div_ceil(new_bids_size, page_size);
        m_page_status.resize(new_pages, uninitialized);
        m_page_to_slot.resize(new_pages, on_disk);

        m_bids.resize(new_bids_size);
        if (m_from == NULL)
        {
            m_bm->new_blocks(m_alloc_strategy,
                             m_bids.begin() + old_bids_size, m_bids.end(),
                             old_bids_size);
        }
        else
        {
            size_type offset = size_type(old_bids_size) * size_type(block_type::raw_size);
            for (bids_container_iterator it = m_bids.begin() + old_bids_size;
                 it != m_bids.end(); ++it, offset += size_type(block_type::raw_size))
            {
                (*it).storage = m_from;
                (*it).offset = offset;
            }
            STXXL_VERBOSE_VECTOR("reserve(): Changing size of file " <<
                                 ((void*)m_from) << " to " << offset);
            m_from->set_size(offset);
        }
    }

    //! Resize vector contents to n items.
    //! \warning this will not call the constructor of objects in external memory!
    void resize(size_type n)
    {
        _resize(n);
    }

    //! Resize vector contents to n items, and allow the allocated external
    //! memory to shrink. Internal memory allocation remains unchanged.
    //! \warning this will not call the constructor of objects in external memory!
    void resize(size_type n, bool shrink_capacity)
    {
        if (shrink_capacity)
            _resize_shrink_capacity(n);
        else
            _resize(n);
    }

    //! \}

private:
    //! Resize vector, only allow capacity growth.
    void _resize(size_type n)
    {
        reserve(n);
        if (n < m_size) {
            // mark excess pages as uninitialized and evict them from cache
            unsigned_type first_page_to_evict = (unsigned_type)div_ceil(n, block_type::size * page_size);
            for (size_t i = first_page_to_evict; i < m_page_status.size(); ++i) {
                if (m_page_to_slot[i] != on_disk) {
                    m_free_slots.push(m_page_to_slot[i]);
                    m_page_to_slot[i] = on_disk;
                }
                m_page_status[i] = uninitialized;
            }
        }
        m_size = n;
    }

    //! Resize vector, also allow reduction of external memory capacity.
    void _resize_shrink_capacity(size_type n)
    {
        unsigned_type old_bids_size = m_bids.size();
        unsigned_type new_bids_size = div_ceil(n, block_type::size);

        if (new_bids_size > old_bids_size)
        {
            reserve(n);
        }
        else if (new_bids_size < old_bids_size)
        {
            unsigned_type new_pages_size = div_ceil(new_bids_size, page_size);

            STXXL_VERBOSE_VECTOR("shrinking from " << old_bids_size << " to " <<
                                 new_bids_size << " blocks = from " <<
                                 m_page_status.size() << " to " <<
                                 new_pages_size << " pages");

            // release blocks
            if (m_from != NULL)
                m_from->set_size(new_bids_size * block_type::raw_size);
            else
                m_bm->delete_blocks(m_bids.begin() + old_bids_size, m_bids.end());

            m_bids.resize(new_bids_size);

            // don't resize m_page_to_slot or m_page_status, because it is
            // still needed to check page status and match the mapping
            // m_slot_to_page

            // clear dirty flag, so these pages will be never written
            std::fill(m_page_status.begin() + new_pages_size,
                      m_page_status.end(), (unsigned char)valid_on_disk);
        }

        m_size = n;
    }

public:
    //! \name Modifiers
    //! \{

    //! Erases all of the elements and deallocates all external memory that is
    //! occupied.
    void clear()
    {
        m_size = 0;
        if (m_from == NULL)
            m_bm->delete_blocks(m_bids.begin(), m_bids.end());

        m_bids.clear();
        m_page_status.clear();
        m_page_to_slot.clear();
        while (!m_free_slots.empty())
            m_free_slots.pop();

        for (unsigned_type i = 0; i < numpages(); ++i)
            m_free_slots.push(i);
    }

    //! \name Front and Back Access
    //! \{

    //! Append a new element at the end.
    void push_back(const_reference obj)
    {
        size_type old_size = m_size;
        resize(old_size + 1);
        element(old_size) = obj;
    }
    //! Removes the last element (without returning it, see back()).
    void pop_back()
    {
        resize(m_size - 1);
    }

    //! \}

    //! \name Operators
    //! \{

    //! Returns a reference to the last element, see \ref design_vector_notes.
    reference back()
    {
        return element(m_size - 1);
    }
    //! Returns a reference to the first element, see \ref design_vector_notes.
    reference front()
    {
        return element(0);
    }
    //! Returns a constant reference to the last element, see \ref design_vector_notes.
    const_reference back() const
    {
        return const_element(m_size - 1);
    }
    //! Returns a constant reference to the first element, see \ref design_vector_notes.
    const_reference front() const
    {
        return const_element(0);
    }

    //! \}

    //! \name Constructors/Destructors
    //! \{

    //! Construct vector from a file.
    //! \param from file to be constructed from
    //! \param size Number of elements.
    //! \param npages Number of cached pages.
    //! \warning Only one \c vector can be assigned to a particular (physical) file.
    //! The block size of the vector must be a multiple of the element size
    //! \c sizeof(ValueType) and the page size (4096).
    vector(file* from, size_type size = size_type(-1), unsigned_type npages = pager_type().size())
        : m_size((size == size_type(-1)) ? size_from_file_length(from->size()) : size),
          m_bids((size_t)div_ceil(m_size, size_type(block_type::size))),
          m_pager(npages),
          m_page_status(div_ceil(m_bids.size(), page_size)),
          m_page_to_slot(div_ceil(m_bids.size(), page_size)),
          m_slot_to_page(npages),
          m_cache(NULL),
          m_from(from),
          m_exported(false)
    {
        // initialize from file
        if (!block_type::has_only_data)
        {
            std::ostringstream str;
            str << "The block size for a vector that is mapped to a file must be a multiple of the element size (" <<
                sizeof(value_type) << ") and the page size (4096).";
            throw std::runtime_error(str.str());
        }

        m_bm = block_manager::get_instance();

        allocate_page_cache();

        for (size_t i = 0; i < m_page_status.size(); ++i)
        {
            m_page_status[i] = valid_on_disk;
            m_page_to_slot[i] = on_disk;
        }

        for (unsigned_type i = 0; i < numpages(); ++i)
            m_free_slots.push(i);


        // allocate blocks equidistantly and in-order
        size_type offset = 0;
        for (bids_container_iterator it = m_bids.begin();
             it != m_bids.end(); ++it, offset += size_type(block_type::raw_size))
        {
            (*it).storage = from;
            (*it).offset = offset;
        }
        from->set_size(offset);
    }

    //! copy-constructor
    vector(const vector& obj)
        : m_size(obj.size()),
          m_bids((size_t)div_ceil(obj.size(), block_type::size)),
          m_pager(obj.numpages()),
          m_page_status(div_ceil(m_bids.size(), page_size)),
          m_page_to_slot(div_ceil(m_bids.size(), page_size)),
          m_slot_to_page(obj.numpages()),
          m_cache(NULL),
          m_from(NULL),
          m_exported(false)
    {
        assert(!obj.m_exported);
        m_bm = block_manager::get_instance();

        allocate_page_cache();

        for (size_t i = 0; i < m_page_status.size(); ++i)
        {
            m_page_status[i] = uninitialized;
            m_page_to_slot[i] = on_disk;
        }

        for (unsigned_type i = 0; i < numpages(); ++i)
            m_free_slots.push(i);

        m_bm->new_blocks(m_alloc_strategy, m_bids.begin(), m_bids.end(), 0);

        const_iterator inbegin = obj.begin();
        const_iterator inend = obj.end();
        std::copy(inbegin, inend, begin());
    }

    //! \}

    //! \name Operators
    //! \{

    //! assignment operator
    vector& operator = (const vector& obj)
    {
        if (&obj != this)
        {
            vector tmp(obj);
            this->swap(tmp);
        }
        return *this;
    }

    //! \}

    //! \name Iterator Construction
    //! \{

    //! returns an iterator pointing to the beginning of the vector, see \ref design_vector_notes.
    iterator begin()
    {
        return iterator(this, 0);
    }
    //! returns a const_iterator pointing to the beginning of the vector, see \ref design_vector_notes.
    const_iterator begin() const
    {
        return const_iterator(this, 0);
    }
    //! returns a const_iterator pointing to the beginning of the vector, see \ref design_vector_notes.
    const_iterator cbegin() const
    {
        return begin();
    }
    //! returns an iterator pointing beyond the end of the vector, see \ref design_vector_notes.
    iterator end()
    {
        return iterator(this, m_size);
    }
    //! returns a const_iterator pointing beyond the end of the vector, see \ref design_vector_notes.
    const_iterator end() const
    {
        return const_iterator(this, m_size);
    }
    //! returns a const_iterator pointing beyond the end of the vector, see \ref design_vector_notes.
    const_iterator cend() const
    {
        return end();
    }

    //! returns a reverse_iterator pointing to the end of the vector.
    reverse_iterator rbegin()
    {
        return reverse_iterator(end());
    }
    //! returns a reverse_iterator pointing to the end of the vector.
    const_reverse_iterator rbegin() const
    {
        return const_reverse_iterator(end());
    }
    //! returns a reverse_iterator pointing to the end of the vector.
    const_reverse_iterator crbegin() const
    {
        return const_reverse_iterator(end());
    }
    //! returns a reverse_iterator pointing beyond the beginning of the vector.
    reverse_iterator rend()
    {
        return reverse_iterator(begin());
    }
    //! returns a reverse_iterator pointing beyond the beginning of the vector.
    const_reverse_iterator rend() const
    {
        return const_reverse_iterator(begin());
    }
    //! returns a reverse_iterator pointing beyond the beginning of the vector.
    const_reverse_iterator crend() const
    {
        return const_reverse_iterator(begin());
    }

    //! \}

    //! \name Direct Element Access
    //! \{

    //! access the element at the given vector's offset
    reference operator [] (size_type offset)
    {
        return element(offset);
    }
    //! access the element at the given vector's offset
    const_reference operator [] (size_type offset) const
    {
        return const_element(offset);
    }

    //! access the element at the given vector's offset
    reference at(size_type offset)
    {
        assert(offset < (size_type)size());
        return element(offset);
    }
    //! access the element at the given vector's offset
    const_reference at(size_type offset) const
    {
        assert(offset < (size_type)size());
        return const_element(offset);
    }

    //! return true if the given vector offset is in cache
    bool is_element_cached(size_type offset) const
    {
        return is_page_cached(blocked_index_type(offset));
    }

    //! \}

    //! \name Modifiers
    //! \{

    //! Flushes the cache pages to the external memory.
    void flush() const
    {
        simple_vector<bool> non_free_slots(numpages());

        for (unsigned_type i = 0; i < numpages(); i++)
            non_free_slots[i] = true;

        while (!m_free_slots.empty())
        {
            non_free_slots[m_free_slots.front()] = false;
            m_free_slots.pop();
        }

        for (unsigned_type i = 0; i < numpages(); i++)
        {
            m_free_slots.push(i);
            int_type page_no = m_slot_to_page[i];
            if (non_free_slots[i])
            {
                STXXL_VERBOSE_VECTOR("flush(): flushing page " << i << " at address " <<
                                     (int64(page_no) * int64(block_type::size) * int64(page_size)));
                write_page(page_no, i);

                m_page_to_slot[page_no] = on_disk;
            }
        }
    }

    //! \}

    //! \name Constructors/Destructors
    //! \{

    ~vector()
    {
        STXXL_VERBOSE_VECTOR("~vector()");
        try
        {
            flush();
        }
        catch (io_error e)
        {
            STXXL_ERRMSG("io_error thrown in ~vector(): " << e.what());
        }
        catch (...)
        {
            STXXL_ERRMSG("Exception thrown in ~vector()");
        }

        if (!m_exported)
        {
            if (m_from == NULL) {
                m_bm->delete_blocks(m_bids.begin(), m_bids.end());
            }
            else // file must be truncated
            {
                STXXL_VERBOSE_VECTOR("~vector(): Changing size of file " <<
                                     ((void*)m_from) << " to " << file_length());
                STXXL_VERBOSE_VECTOR("~vector(): size of the vector is " << size());
                try
                {
                    m_from->set_size(file_length());
                }
                catch (...)
                {
                    STXXL_ERRMSG("Exception thrown in ~vector()...set_size()");
                }
            }
        }
        delete m_cache;
    }

    //! \}

    //! \name Miscellaneous
    //! \{

    //! Export data such that it is persistent on the file system. Resulting
    //! files will be numbered ascending.
    void export_files(std::string filename_prefix)
    {
        int64 no = 0;
        for (bids_container_iterator i = m_bids.begin(); i != m_bids.end(); ++i) {
            std::ostringstream number;
            number << std::setw(9) << std::setfill('0') << no;
            size_type current_block_size =
                ((i + 1) == m_bids.end() && m_size % block_type::size > 0) ?
                (m_size % block_type::size) * sizeof(value_type) :
                block_type::size * sizeof(value_type);
            (*i).storage->export_files((*i).offset, current_block_size, filename_prefix + number.str());
            ++no;
        }
        m_exported = true;
    }

    //! Get the file associated with this vector, or NULL.
    file * get_file() const
    {
        return m_from;
    }

    //! \}

    //! \name Capacity
    //! \{

    //! Set the blocks and the size of this container explicitly.
    //! The vector must be completely empty before.
    template <typename ForwardIterator>
    void set_content(const ForwardIterator& bid_begin, const ForwardIterator& bid_end, size_type n)
    {
        unsigned_type new_bids_size = div_ceil(n, block_type::size);
        m_bids.resize(new_bids_size);
        std::copy(bid_begin, bid_end, m_bids.begin());
        unsigned_type new_pages = div_ceil(new_bids_size, page_size);
        m_page_status.resize(new_pages, valid_on_disk);
        m_page_to_slot.resize(new_pages, on_disk);
        m_size = n;
    }

    //! Number of pages used by the pager.
    inline unsigned_type numpages() const
    {
        return m_pager.size();
    }

    //! \}

private:
    bids_container_iterator bid(const size_type& offset)
    {
        return (m_bids.begin() +
                static_cast<typename bids_container_type::size_type>
                (offset / block_type::size));
    }
    bids_container_iterator bid(const blocked_index_type& offset)
    {
        return (m_bids.begin() +
                static_cast<typename bids_container_type::size_type>
                (offset.get_block2() * PageSize + offset.get_block1()));
    }
    const_bids_container_iterator bid(const size_type& offset) const
    {
        return (m_bids.begin() +
                static_cast<typename bids_container_type::size_type>
                (offset / block_type::size));
    }
    const_bids_container_iterator bid(const blocked_index_type& offset) const
    {
        return (m_bids.begin() +
                static_cast<typename bids_container_type::size_type>
                (offset.get_block2() * PageSize + offset.get_block1()));
    }

    void read_page(int_type page_no, int_type cache_slot) const
    {
        assert(page_no < (int_type)m_page_status.size());
        if (m_page_status[page_no] == uninitialized)
            return;
        STXXL_VERBOSE_VECTOR("read_page(): page_no=" << page_no << " cache_slot=" << cache_slot);
        request_ptr* reqs = new request_ptr[page_size];
        int_type block_no = page_no * page_size;
        int_type last_block = STXXL_MIN(block_no + page_size, int_type(m_bids.size()));
        int_type i = cache_slot * page_size, j = 0;
        for ( ; block_no < last_block; ++block_no, ++i, ++j)
        {
            reqs[j] = (*m_cache)[i].read(m_bids[block_no]);
        }
        assert(last_block - page_no * page_size > 0);
        wait_all(reqs, last_block - page_no * page_size);
        delete[] reqs;
    }
    void write_page(int_type page_no, int_type cache_slot) const
    {
        assert(page_no < (int_type)m_page_status.size());
        if (!(m_page_status[page_no] & dirty))
            return;
        STXXL_VERBOSE_VECTOR("write_page(): page_no=" << page_no << " cache_slot=" << cache_slot);
        request_ptr* reqs = new request_ptr[page_size];
        int_type block_no = page_no * page_size;
        int_type last_block = STXXL_MIN(block_no + page_size, int_type(m_bids.size()));
        assert(block_no < last_block);
        int_type i = cache_slot * page_size, j = 0;
        for ( ; block_no < last_block; ++block_no, ++i, ++j)
        {
            reqs[j] = (*m_cache)[i].write(m_bids[block_no]);
        }
        m_page_status[page_no] = valid_on_disk;
        assert(last_block - page_no * page_size > 0);
        wait_all(reqs, last_block - page_no * page_size);
        delete[] reqs;
    }

    reference element(size_type offset)
    {
#ifdef STXXL_RANGE_CHECK
        assert(offset < (size_type)size());
#endif
        return element(blocked_index_type(offset));
    }

    reference element(const blocked_index_type& offset)
    {
#ifdef STXXL_RANGE_CHECK
        assert(offset.get_pos() < size());
#endif
        unsigned_type page_no = offset.get_block2();
        assert(page_no < m_page_to_slot.size());   // fails if offset is too large, out of bound access
        int_type cache_slot = m_page_to_slot[page_no];
        if (cache_slot < 0)                        // == on_disk
        {
            if (m_free_slots.empty())              // has to kick
            {
                int_type kicked_slot = m_pager.kick();
                m_pager.hit(kicked_slot);
                int_type old_page_no = m_slot_to_page[kicked_slot];
                m_page_to_slot[page_no] = kicked_slot;
                m_page_to_slot[old_page_no] = on_disk;
                m_slot_to_page[kicked_slot] = page_no;

                write_page(old_page_no, kicked_slot);
                read_page(page_no, kicked_slot);

                m_page_status[page_no] = dirty;

                return (*m_cache)[kicked_slot * page_size + offset.get_block1()][offset.get_offset()];
            }
            else
            {
                int_type free_slot = m_free_slots.front();
                m_free_slots.pop();
                m_pager.hit(free_slot);
                m_page_to_slot[page_no] = free_slot;
                m_slot_to_page[free_slot] = page_no;

                read_page(page_no, free_slot);

                m_page_status[page_no] = dirty;

                return (*m_cache)[free_slot * page_size + offset.get_block1()][offset.get_offset()];
            }
        }
        else
        {
            m_page_status[page_no] = dirty;
            m_pager.hit(cache_slot);
            return (*m_cache)[cache_slot * page_size + offset.get_block1()][offset.get_offset()];
        }
    }

    // don't forget to first flush() the vector's cache before updating pages externally
    void page_externally_updated(unsigned_type page_no) const
    {
        // fails if offset is too large, out of bound access
        assert(page_no < m_page_status.size());
        // "A dirty page has been marked as newly initialized. The page content will be lost."
        assert(!(m_page_status[page_no] & dirty));
        if (m_page_to_slot[page_no] != on_disk) {
            // remove page from cache
            m_free_slots.push(m_page_to_slot[page_no]);
            m_page_to_slot[page_no] = on_disk;
            STXXL_VERBOSE_VECTOR("page_externally_updated(): page_no=" << page_no << " flushed from cache.");
        }
        else {
            STXXL_VERBOSE_VECTOR("page_externally_updated(): page_no=" << page_no << " no need to flush.");
        }
        m_page_status[page_no] = valid_on_disk;
    }

    void block_externally_updated(size_type offset) const
    {
        page_externally_updated(offset / (block_type::size * page_size));
    }

    void block_externally_updated(const blocked_index_type& offset) const
    {
        page_externally_updated(offset.get_block2());
    }

    const_reference const_element(size_type offset) const
    {
        return const_element(blocked_index_type(offset));
    }

    const_reference const_element(const blocked_index_type& offset) const
    {
        unsigned_type page_no = offset.get_block2();
        assert(page_no < m_page_to_slot.size());   // fails if offset is too large, out of bound access
        int_type cache_slot = m_page_to_slot[page_no];
        if (cache_slot < 0)                        // == on_disk
        {
            if (m_free_slots.empty())              // has to kick
            {
                int_type kicked_slot = m_pager.kick();
                m_pager.hit(kicked_slot);
                int_type old_page_no = m_slot_to_page[kicked_slot];
                m_page_to_slot[page_no] = kicked_slot;
                m_page_to_slot[old_page_no] = on_disk;
                m_slot_to_page[kicked_slot] = page_no;

                write_page(old_page_no, kicked_slot);
                read_page(page_no, kicked_slot);

                return (*m_cache)[kicked_slot * page_size + offset.get_block1()][offset.get_offset()];
            }
            else
            {
                int_type free_slot = m_free_slots.front();
                m_free_slots.pop();
                m_pager.hit(free_slot);
                m_page_to_slot[page_no] = free_slot;
                m_slot_to_page[free_slot] = page_no;

                read_page(page_no, free_slot);

                return (*m_cache)[free_slot * page_size + offset.get_block1()][offset.get_offset()];
            }
        }
        else
        {
            m_pager.hit(cache_slot);
            return (*m_cache)[cache_slot * page_size + offset.get_block1()][offset.get_offset()];
        }
    }

    bool is_page_cached(const blocked_index_type& offset) const
    {
        unsigned_type page_no = offset.get_block2();
        assert(page_no < m_page_to_slot.size());   // fails if offset is too large, out of bound access
        int_type cache_slot = m_page_to_slot[page_no];
        return (cache_slot >= 0);                  // on_disk == -1
    }
};

template <
    typename ValueType,
    unsigned PageSize,
    typename PagerType,
    unsigned BlockSize,
    typename AllocStr,
    typename SizeType>
inline bool operator == (stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                       AllocStr, SizeType>& a,
                         stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                       AllocStr, SizeType>& b)
{
    return a.size() == b.size() && std::equal(a.begin(), a.end(), b.begin());
}

template <
    typename ValueType,
    unsigned PageSize,
    typename PagerType,
    unsigned BlockSize,
    typename AllocStr,
    typename SizeType>
inline bool operator != (stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                       AllocStr, SizeType>& a,
                         stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                       AllocStr, SizeType>& b)
{
    return !(a == b);
}

template <
    typename ValueType,
    unsigned PageSize,
    typename PagerType,
    unsigned BlockSize,
    typename AllocStr,
    typename SizeType>
inline bool operator < (stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                      AllocStr, SizeType>& a,
                        stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                      AllocStr, SizeType>& b)
{
    return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
}

template <
    typename ValueType,
    unsigned PageSize,
    typename PagerType,
    unsigned BlockSize,
    typename AllocStr,
    typename SizeType>
inline bool operator > (stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                      AllocStr, SizeType>& a,
                        stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                      AllocStr, SizeType>& b)
{
    return b < a;
}

template <
    typename ValueType,
    unsigned PageSize,
    typename PagerType,
    unsigned BlockSize,
    typename AllocStr,
    typename SizeType>
inline bool operator <= (stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                       AllocStr, SizeType>& a,
                         stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                       AllocStr, SizeType>& b)
{
    return !(b < a);
}

template <
    typename ValueType,
    unsigned PageSize,
    typename PagerType,
    unsigned BlockSize,
    typename AllocStr,
    typename SizeType>
inline bool operator >= (stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                       AllocStr, SizeType>& a,
                         stxxl::vector<ValueType, PageSize, PagerType, BlockSize,
                                       AllocStr, SizeType>& b)
{
    return !(a < b);
}

////////////////////////////////////////////////////////////////////////////

// specialization for stxxl::vector, to use only const_iterators
template <typename ValueType, typename AllocStr, typename SizeType, typename DiffType,
          unsigned BlockSize, typename PagerType, unsigned PageSize>
bool is_sorted(
    stxxl::vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize> __first,
    stxxl::vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize> __last)
{
    return is_sorted_helper(
        stxxl::const_vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize>(__first),
        stxxl::const_vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize>(__last));
}

template <typename ValueType, typename AllocStr, typename SizeType, typename DiffType,
          unsigned BlockSize, typename PagerType, unsigned PageSize, typename _StrictWeakOrdering>
bool is_sorted(
    stxxl::vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize> __first,
    stxxl::vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize> __last,
    _StrictWeakOrdering __comp)
{
    return is_sorted_helper(
        stxxl::const_vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize>(__first),
        stxxl::const_vector_iterator<ValueType, AllocStr, SizeType, DiffType, BlockSize, PagerType, PageSize>(__last),
        __comp);
}

////////////////////////////////////////////////////////////////////////////

template <typename VectorBufReaderType>
class vector_bufreader_iterator;

/*!
 * Buffered sequential reader from a vector using overlapped I/O.
 *
 * This buffered reader can be used to read a large sequential region of a
 * vector using overlapped I/O. The object is created from an iterator range,
 * which can then be read to using operator<<(), or with operator*() and
 * operator++().
 *
 * The interface also fulfills all requirements of a stream. Actually most of
 * the code is identical to stream::vector_iterator2stream.
 *
 * Note that this buffered reader is inefficient for reading small ranges. This
 * is intentional, as one can just use operator[] on the vector for that.
 *
 * See \ref tutorial_vector_buf
 */
template <typename VectorIterator>
class vector_bufreader : public noncopyable
{
public:
    //! template parameter: the vector iterator type
    typedef VectorIterator vector_iterator;

    //! value type of the output vector
    typedef typename vector_iterator::value_type value_type;

    //! block type used in the vector
    typedef typename vector_iterator::block_type block_type;

    //! type of the input vector
    typedef typename vector_iterator::vector_type vector_type;

    //! block identifier iterator of the vector
    typedef typename vector_iterator::bids_container_iterator bids_container_iterator;

    //! construct output buffered stream used for overlapped reading
    typedef buf_istream<block_type, bids_container_iterator> buf_istream_type;

    //! construct an iterator for vector_bufreader (for C++11 range-based for loop)
    typedef vector_bufreader_iterator<vector_bufreader> bufreader_iterator;

protected:
    //! iterator to the beginning of the range.
    vector_iterator m_begin;

    //! internal "current" iterator into the vector.
    vector_iterator m_iter;

    //! iterator to the end of the range.
    vector_iterator m_end;

    //! buffered input stream used to overlapped I/O.
    buf_istream_type* m_bufin;

    //! number of blocks to use as buffers.
    unsigned_type m_nbuffers;

    //! allow vector_bufreader_iterator to check m_iter against its current value
    friend class vector_bufreader_iterator<vector_bufreader>;

public:
    //! Create overlapped reader for the given iterator range.
    //! \param begin iterator to position were to start reading in vector
    //! \param end iterator to position were to end reading in vector
    //! \param nbuffers number of buffers used for overlapped I/O (>= 2*D recommended)
    vector_bufreader(vector_iterator begin, vector_iterator end, unsigned_type nbuffers = 0)
        : m_begin(begin), m_end(end),
          m_bufin(NULL),
          m_nbuffers(nbuffers)
    {
        m_begin.flush(); // flush container

        if (m_nbuffers == 0)
            m_nbuffers = 2 * config::get_instance()->disks_number();

        rewind();
    }

    //! Create overlapped reader for the whole vector's content.
    //! \param vec vector to read
    //! \param nbuffers number of buffers used for overlapped I/O (>= 2*D recommended)
    vector_bufreader(const vector_type& vec, unsigned_type nbuffers = 0)
        : m_begin(vec.begin()), m_end(vec.end()),
          m_bufin(NULL),
          m_nbuffers(nbuffers)
    {
        m_begin.flush(); // flush container

        if (m_nbuffers == 0)
            m_nbuffers = 2 * config::get_instance()->disks_number();

        rewind();
    }

    //! Rewind stream back to begin. Note that this recreates the buffered
    //! reader and is thus not cheap.
    void rewind()
    {
        m_iter = m_begin;
        if (empty()) return;

        if (m_bufin) delete m_bufin;

        // find last bid to read
        bids_container_iterator end_bid = m_end.bid() + (m_end.block_offset() ? 1 : 0);

        // construct buffered istream for range
        m_bufin = new buf_istream_type(m_begin.bid(), end_bid, m_nbuffers);

        // skip the beginning of the block, up to real beginning
        vector_iterator curr = m_begin - m_begin.block_offset();

        for ( ; curr != m_begin; ++curr)
            ++(*m_bufin);
    }

    //! Finish reading and free buffered reader.
    ~vector_bufreader()
    {
        if (m_bufin) delete m_bufin;
    }

    //! Return constant reference to current item
    const value_type& operator * () const
    {
        return *(*m_bufin);
    }

    //! Return constant pointer to current item
    const value_type* operator -> () const
    {
        return &(*(*m_bufin));
    }

    //! Advance to next item (asserts if !empty()).
    vector_bufreader& operator ++ ()
    {
        assert(!empty());
        ++m_iter;
        ++(*m_bufin);

        if (UNLIKELY(empty())) {
            delete m_bufin;
            m_bufin = NULL;
        }

        return *this;
    }

    //! Read current item into variable and advance to next one.
    vector_bufreader& operator >> (value_type& v)
    {
        v = operator * ();
        operator ++ ();

        return *this;
    }

    //! Return remaining size.
    size_t size() const
    {
        assert(m_begin <= m_iter && m_iter <= m_end);
        return (m_end - m_iter);
    }

    //! Returns true once the whole range has been read.
    bool empty() const
    {
        return (m_iter == m_end);
    }

    //! Return vector_bufreader_iterator for C++11 range-based for loop
    bufreader_iterator begin()
    {
        return bufreader_iterator(*this, m_begin);
    }

    //! Return vector_bufreader_iterator for C++11 range-based for loop
    bufreader_iterator end()
    {
        return bufreader_iterator(*this, m_end);
    }
};

////////////////////////////////////////////////////////////////////////////

/*!
 * Adapter for vector_bufreader to match iterator requirements of C++11
 * range-based loop construct.
 *
 * Since vector_bufreader itself points to only one specific item, this
 * iterator is merely a counter facade. The functions operator*() and
 * operator++() must only be called when it is in _sync_ with the bufreader
 * object. This is generally only the case for an iterator constructed with
 * begin() and then advanced with operator++(). The class checks this using
 * asserts(), the operators will fail if used wrong.
 *
 * See \ref tutorial_vector_buf
 */
template <typename VectorBufReaderType>
class vector_bufreader_iterator
{
public:
    //! The underlying buffered reader type
    typedef VectorBufReaderType vector_bufreader_type;

    //! Value type of vector
    typedef typename vector_bufreader_type::value_type value_type;

    //! Use vector_iterator to reference a point in the vector.
    typedef typename vector_bufreader_type::vector_iterator vector_iterator;

protected:
    //! Buffered reader used to access elements in vector
    vector_bufreader_type& m_bufreader;

    //! Use vector_iterator to reference a point in the vector.
    vector_iterator m_iter;

public:
    //! Construct iterator using vector_iterator
    vector_bufreader_iterator(vector_bufreader_type& bufreader, const vector_iterator& iter)
        : m_bufreader(bufreader), m_iter(iter)
    { }

    //! Return constant reference to current item
    const value_type& operator * () const
    {
        assert(m_bufreader.m_iter == m_iter);
        return m_bufreader.operator * ();
    }

    //! Return constant pointer to current item
    const value_type* operator -> () const
    {
        assert(m_bufreader.m_iter == m_iter);
        return m_bufreader.operator -> ();
    }

    //! Make bufreader advance to next item (asserts if !empty() or if iterator
    //! does not point to current).
    vector_bufreader_iterator& operator ++ ()
    {
        assert(m_bufreader.m_iter == m_iter);
        m_bufreader.operator ++ ();
        m_iter++;
        return *this;
    }

    //! Equality comparison operator
    bool operator == (const vector_bufreader_iterator& vbi) const
    {
        assert(&m_bufreader == &vbi.m_bufreader);
        return (m_iter == vbi.m_iter);
    }

    //! Inequality comparison operator
    bool operator != (const vector_bufreader_iterator& vbi) const
    {
        assert(&m_bufreader == &vbi.m_bufreader);
        return (m_iter != vbi.m_iter);
    }
};

////////////////////////////////////////////////////////////////////////////

/*!
 * Buffered sequential reverse reader from a vector using overlapped I/O.
 *
 * This buffered reader can be used to read a large sequential region of a
 * vector _in_reverse_ using overlapped I/O. The object is created from an
 * iterator range, which can then be read to using operator<<(), or with
 * operator*() and operator++(), where ++ actually goes to the preceding
 * element.
 *
 * The interface also fulfills all requirements of a stream. Actually most of
 * the code is identical to stream::vector_iterator2stream.
 *
 * Note that this buffered reader is inefficient for reading small ranges. This
 * is intentional, as one can just use operator[] on the vector for that.
 *
 * See \ref tutorial_vector_buf
 */
template <typename VectorIterator>
class vector_bufreader_reverse : public noncopyable
{
public:
    //! template parameter: the vector iterator type
    typedef VectorIterator vector_iterator;

    //! value type of the output vector
    typedef typename vector_iterator::value_type value_type;

    //! block type used in the vector
    typedef typename vector_iterator::block_type block_type;

    //! type of the input vector
    typedef typename vector_iterator::vector_type vector_type;

    //! block identifier iterator of the vector
    typedef typename vector_iterator::bids_container_iterator bids_container_iterator;

    //! construct output buffered stream used for overlapped reading
    typedef buf_istream_reverse<block_type, bids_container_iterator> buf_istream_type;

protected:
    //! iterator to the beginning of the range.
    vector_iterator m_begin;

    //! internal "current" iterator into the vector.
    vector_iterator m_iter;

    //! iterator to the end of the range.
    vector_iterator m_end;

    //! buffered input stream used to overlapped I/O.
    buf_istream_type* m_bufin;

    //! number of blocks to use as buffers.
    unsigned_type m_nbuffers;

public:
    //! Create overlapped reader for the given iterator range.
    //! \param begin iterator to position were to start reading in vector
    //! \param end iterator to position were to end reading in vector
    //! \param nbuffers number of buffers used for overlapped I/O (>= 2*D recommended)
    vector_bufreader_reverse(vector_iterator begin, vector_iterator end, unsigned_type nbuffers = 0)
        : m_begin(begin), m_end(end),
          m_bufin(NULL),
          m_nbuffers(nbuffers)
    {
        m_begin.flush(); // flush container

        if (m_nbuffers == 0)
            m_nbuffers = 2 * config::get_instance()->disks_number();

        rewind();
    }

    //! Create overlapped reader for the whole vector's content.
    //! \param vec vector to read
    //! \param nbuffers number of buffers used for overlapped I/O (>= 2*D recommended)
    vector_bufreader_reverse(const vector_type& vec, unsigned_type nbuffers = 0)
        : m_begin(vec.begin()), m_end(vec.end()),
          m_bufin(NULL),
          m_nbuffers(nbuffers)
    {
        m_begin.flush(); // flush container

        if (m_nbuffers == 0)
            m_nbuffers = 2 * config::get_instance()->disks_number();

        rewind();
    }

    //! Rewind stream back to begin. Note that this recreates the buffered
    //! reader and is thus not cheap.
    void rewind()
    {
        m_iter = m_end;
        if (empty()) return;

        if (m_bufin) delete m_bufin;

        // find last bid to read
        bids_container_iterator end_bid = m_end.bid() + (m_end.block_offset() ? 1 : 0);

        // construct buffered istream_reverse for range
        m_bufin = new buf_istream_type(m_begin.bid(), end_bid, m_nbuffers);

        // skip to beginning of reverse sequence.
        stxxl::int_type endoff = m_end.block_offset();
        if (endoff == 0) {
            // nothing to skip
        }
        else {
            // else, let ifstream_reverse skip last elements at end of block,
            // up to real end
            for ( ; endoff != block_type::size; endoff++)
                ++(*m_bufin);
        }
    }

    //! Finish reading and free buffered reader.
    ~vector_bufreader_reverse()
    {
        if (m_bufin) delete m_bufin;
    }

    //! Return constant reference to current item
    const value_type& operator * () const
    {
        return *(*m_bufin);
    }

    //! Return constant pointer to current item
    const value_type* operator -> () const
    {
        return &(*(*m_bufin));
    }

    //! Advance to next item (asserts if !empty()).
    vector_bufreader_reverse& operator ++ ()
    {
        assert(!empty());
        --m_iter;
        ++(*m_bufin);

        if (UNLIKELY(empty())) {
            delete m_bufin;
            m_bufin = NULL;
        }

        return *this;
    }

    //! Read current item into variable and advance to next one.
    vector_bufreader_reverse& operator >> (value_type& v)
    {
        v = operator * ();
        operator ++ ();

        return *this;
    }

    //! Return remaining size.
    size_t size() const
    {
        assert(m_begin <= m_iter && m_iter <= m_end);
        return (m_iter - m_begin);
    }

    //! Returns true once the whole range has been read.
    bool empty() const
    {
        return (m_iter == m_begin);
    }
};

////////////////////////////////////////////////////////////////////////////

/*!
 * Buffered sequential writer to a vector using overlapped I/O.
 *
 * This buffered writer can be used to write a large sequential region of a
 * vector using overlapped I/O. The object is created from an iterator range,
 * which can then be written to using operator << (), or with operator * () and
 * operator ++ ().
 *
 * The buffered writer is given one iterator in the constructor. When writing,
 * this iterator advances in the vector and will \b enlarge the vector once it
 * reaches the end(). The vector size is doubled each time; nevertheless, it is
 * better to preinitialize the vector's size using stxxl::vector::resize().
 *
 * See \ref tutorial_vector_buf
 */
template <typename VectorIterator>
class vector_bufwriter : public noncopyable
{
public:
    //! template parameter: the vector iterator type
    typedef VectorIterator iterator;

    //! type of the output vector
    typedef typename iterator::vector_type vector_type;

    //! value type of the output vector
    typedef typename iterator::value_type value_type;

    //! block type used in the vector
    typedef typename iterator::block_type block_type;

    //! block identifier iterator of the vector
    typedef typename iterator::bids_container_iterator bids_container_iterator;

    //! iterator type of vector
    typedef typename iterator::iterator vector_iterator;
    typedef typename iterator::const_iterator vector_const_iterator;

    //! construct output buffered stream used for overlapped writing
    typedef buf_ostream<block_type, bids_container_iterator> buf_ostream_type;

protected:
    //! internal iterator into the vector.
    vector_iterator m_iter;

    //! iterator to the current end of the vector.
    vector_const_iterator m_end;

    //! boolean whether the vector was grown, will shorten at finish().
    bool m_grown;

    //! iterator into vector of the last block accessed (used to issue updates
    //! when the block is switched).
    vector_const_iterator m_prevblk;

    //! buffered output stream used to overlapped I/O.
    buf_ostream_type* m_bufout;

    //! number of blocks to use as buffers.
    unsigned_type m_nbuffers;

public:
    //! Create overlapped writer beginning at the given iterator.
    //! \param begin iterator to position were to start writing in vector
    //! \param nbuffers number of buffers used for overlapped I/O (>= 2D recommended)
    vector_bufwriter(vector_iterator begin,
                     unsigned_type nbuffers = 0)
        : m_iter(begin),
          m_end(m_iter.parent_vector()->end()),
          m_grown(false),
          m_bufout(NULL),
          m_nbuffers(nbuffers)
    {
        if (m_nbuffers == 0)
            m_nbuffers = 2 * config::get_instance()->disks_number();

        assert(m_iter <= m_end);
    }

    //! Create overlapped writer for the vector's beginning
    //! \param vec vector to write
    //! \param nbuffers number of buffers used for overlapped I/O (>= 2D recommended)
    vector_bufwriter(vector_type& vec,
                     unsigned_type nbuffers = 0)
        : m_iter(vec.begin()),
          m_end(m_iter.parent_vector()->end()),
          m_grown(false),
          m_bufout(NULL),
          m_nbuffers(nbuffers)
    {
        if (m_nbuffers == 0)
            m_nbuffers = 2 * config::get_instance()->disks_number();

        assert(m_iter <= m_end);
    }

    //! Finish writing and flush output back to vector.
    ~vector_bufwriter()
    {
        finish();
    }

    //! Return mutable reference to item at the position of the internal
    //! iterator.
    value_type& operator * ()
    {
        if (UNLIKELY(m_iter == m_end))
        {
            // iterator points to end of vector -> double vector's size

            if (m_bufout) {
                m_bufout->flush(); // flush overlap buffers
                delete m_bufout;
                m_bufout = NULL;

                if (m_iter.block_offset() != 0)
                    m_iter.block_externally_updated();
            }

            vector_type& v = *m_iter.parent_vector();
            if (v.size() < 2 * block_type::size) {
                v.resize(2 * block_type::size);
            }
            else {
                v.resize(2 * v.size());
            }
            m_end = v.end();
            m_grown = true;
        }

        assert(m_iter < m_end);

        if (UNLIKELY(m_bufout == NULL))
        {
            if (m_iter.block_offset() != 0)
            {
                // output position is not at the start of the block, we
                // continue to use the iterator initially passed to the
                // constructor.
                return *m_iter;
            }
            else
            {
                // output position is start of block: create buffered writer

                m_iter.flush(); // flush container

                // create buffered write stream for blocks
                m_bufout = new buf_ostream_type(m_iter.bid(), m_nbuffers);
                m_prevblk = m_iter;

                // drop through to normal output into buffered writer
            }
        }

        // if the pointer has finished a block, then we inform the vector that
        // this block has been updated.
        if (UNLIKELY(m_iter.block_offset() == 0)) {
            if (m_prevblk != m_iter) {
                m_prevblk.block_externally_updated();
                m_prevblk = m_iter;
            }
        }

        return m_bufout->operator * ();
    }

    //! Advance internal iterator.
    vector_bufwriter& operator ++ ()
    {
        // always advance internal iterator
        ++m_iter;

        // if buf_ostream active, advance that too
        if (LIKELY(m_bufout != NULL)) m_bufout->operator ++ ();

        return *this;
    }

    //! Write value to the current position and advance the internal iterator.
    vector_bufwriter& operator << (const value_type& v)
    {
        operator * () = v;
        operator ++ ();

        return *this;
    }

    //! Finish writing and flush output back to vector.
    void finish()
    {
        if (m_bufout)
        {
            // must finish the block started in the buffered writer: fill it with
            // the data in the vector
            vector_const_iterator const_out = m_iter;

            while (const_out.block_offset() != 0)
            {
                m_bufout->operator * () = *const_out;
                m_bufout->operator ++ ();
                ++const_out;
            }

            // inform the vector that the block has been updated.
            if (m_prevblk != m_iter) {
                m_prevblk.block_externally_updated();
                m_prevblk = m_iter;
            }

            delete m_bufout;
            m_bufout = NULL;
        }

        if (m_grown)
        {
            vector_type& v = *m_iter.parent_vector();
            v.resize(m_iter - v.begin());

            m_grown = false;
        }
    }
};

////////////////////////////////////////////////////////////////////////////

//! \brief External vector type generator.
//!
//! \tparam ValueType element type of contained objects (POD with no references to internal memory)
//! \tparam PageSize number of blocks in a page, default: \b 4 (recommended >= D)
//! \tparam CachePages number of pages in cache, default: \b 8 (recommended >= 2)
//! \tparam BlockSize external block size \a B in bytes, default: <b>2 MiB</b>
//! \tparam AllocStr parallel disk allocation strategies: \c striping, RC, SR, or FR. default: \b RC.
//! \tparam Pager pager type: \c random or \c lru, default: \b lru.
//!
//! \warning Do not store references to the elements of an external vector. Such references
//! might be invalidated during any following access to elements of the vector
template <
    typename ValueType,
    unsigned PageSize = 4,
    unsigned CachePages = 8,
    unsigned BlockSize = STXXL_DEFAULT_BLOCK_SIZE(ValueType),
    typename AllocStr = STXXL_DEFAULT_ALLOC_STRATEGY,
    pager_type Pager = lru
    >
struct VECTOR_GENERATOR
{
    typedef typename IF<Pager == lru,
                        lru_pager<CachePages>, random_pager<CachePages> >::result PagerType;

    typedef vector<ValueType, PageSize, PagerType, BlockSize, AllocStr> result;
};

//! \}

STXXL_END_NAMESPACE

namespace std {

template <
    typename ValueType,
    unsigned PageSize,
    typename PagerType,
    unsigned BlockSize,
    typename AllocStr,
    typename SizeType>
void swap(stxxl::vector<ValueType, PageSize, PagerType, BlockSize, AllocStr, SizeType>& a,
          stxxl::vector<ValueType, PageSize, PagerType, BlockSize, AllocStr, SizeType>& b)
{
    a.swap(b);
}

} // namespace std

#endif // !STXXL_CONTAINERS_VECTOR_HEADER
// vim: et:ts=4:sw=4