read_write_pool.h

/***************************************************************************
 * include/stxxl/bits/mng/read_write_pool.h
 *
 * Part of the STXXL. See http://stxxl.sourceforge.net
 *
 * Copyright (C) 2009 Andreas Beckmann <[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_MNG_READ_WRITE_POOL_H
#define STXXL_MNG_READ_WRITE_POOL_H

#include <stxxl/bits/mng/write_pool.h>
#include <stxxl/bits/mng/prefetch_pool.h>


__STXXL_BEGIN_NAMESPACE



template <typename BlockType>
class read_write_pool : private noncopyable
{
public:
 typedef BlockType block_type;
 typedef typename block_type::bid_type bid_type;
 typedef unsigned_type size_type;

protected:
 typedef write_pool<block_type> write_pool_type;
 typedef prefetch_pool<block_type> prefetch_pool_type;

 write_pool_type * w_pool;
 prefetch_pool_type * p_pool;
 bool delete_pools;

public:
 explicit read_write_pool(size_type init_size_prefetch = 1, size_type init_size_write = 1) :
 delete_pools(true)
 {
 w_pool = new write_pool_type(init_size_write);
 p_pool = new prefetch_pool_type(init_size_prefetch);
 }

 _STXXL_DEPRECATED(read_write_pool(prefetch_pool_type & p_pool, write_pool_type & w_pool)) :
 w_pool(&w_pool), p_pool(&p_pool), delete_pools(false)
 { }

 void swap(read_write_pool & obj)
 {
 std::swap(w_pool, obj.w_pool);
 std::swap(p_pool, obj.p_pool);
 std::swap(delete_pools, obj.delete_pools);
 }

 virtual ~read_write_pool()
 {
 if (delete_pools) {
 delete w_pool;
 delete p_pool;
 }
 }

 size_type size_write() const { return w_pool->size(); }

 size_type size_prefetch() const { return p_pool->size(); }

 void resize_write(size_type new_size)
 {
 w_pool->resize(new_size);
 }

 void resize_prefetch(size_type new_size)
 {
 p_pool->resize(new_size);
 }

 // WRITE POOL METHODS

 request_ptr write(block_type * & block, bid_type bid)
 {
 request_ptr result = w_pool->write(block, bid);

 // if there is a copy of this block in the prefetch pool,
 // it is now a stale copy, so invalidate it and re-hint the block
 if (p_pool->invalidate(bid))
 p_pool->hint(bid, *w_pool);

 return result;
 }

 block_type * steal()
 {
 return w_pool->steal();
 }

 void add(block_type * & block)
 {
 w_pool->add(block);
 }

 // PREFETCH POOL METHODS

 bool hint(bid_type bid)
 {
 return p_pool->hint(bid, *w_pool);
 }

 bool invalidate(bid_type bid)
 {
 return p_pool->invalidate(bid);
 }

 request_ptr read(block_type * & block, bid_type bid)
 {
 return p_pool->read(block, bid, *w_pool);
 }
};


__STXXL_END_NAMESPACE


namespace std
{
 template <class BlockType>
 void swap(stxxl::read_write_pool<BlockType> & a,
 stxxl::read_write_pool<BlockType> & b)
 {
 a.swap(b);
 }
}

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