adaptor.h

Go to the documentation of this file.

/***************************************************************************
 * include/stxxl/bits/algo/adaptor.h
 *
 * Part of the STXXL. See http://stxxl.sourceforge.net
 *
 * Copyright (C) 2002 Roman Dementiev <[email protected]>
 * Copyright (C) 2010 Andreas Beckmann <[email protected]>
 * Copyright (C) 2014 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_ALGO_ADAPTOR_HEADER
#define STXXL_ALGO_ADAPTOR_HEADER

#include <stxxl/bits/mng/bid.h>
#include <stxxl/bits/mng/adaptor.h>

STXXL_BEGIN_NAMESPACE

template <unsigned BlockSize, typename RunType, class PosType = int_type>
struct runs2bid_array_adaptor : public two2one_dim_array_adapter_base<RunType*, BID<BlockSize>, PosType>
{
 typedef runs2bid_array_adaptor<BlockSize, RunType, PosType> self_type;
 typedef BID<BlockSize> data_type;

 enum {
 block_size = BlockSize
 };

 unsigned_type dim_size;

 typedef two2one_dim_array_adapter_base<RunType*, BID<BlockSize>, PosType> parent_type;
 using parent_type::array;
 using parent_type::pos;

 runs2bid_array_adaptor(RunType** a, PosType p, unsigned_type d)
 : two2one_dim_array_adapter_base<RunType*, BID<BlockSize>, PosType>(a, p), dim_size(d)
 { }
 runs2bid_array_adaptor(const self_type& a)
 : two2one_dim_array_adapter_base<RunType*, BID<BlockSize>, PosType>(a), dim_size(a.dim_size)
 { }

 const self_type& operator = (const self_type& a)
 {
 array = a.array;
 pos = a.pos;
 dim_size = a.dim_size;
 return *this;
 }

 data_type& operator * ()
 {
 CHECK_RUN_BOUNDS(pos);
 return (BID<BlockSize>&)((*(array[(pos) % dim_size]))[(pos) / dim_size].bid);
 }

 const data_type* operator -> () const
 {
 CHECK_RUN_BOUNDS(pos);
 return &((*(array[(pos) % dim_size])[(pos) / dim_size].bid));
 }

 data_type& operator [] (PosType n) const
 {
 n += pos;
 CHECK_RUN_BOUNDS(n);
 return (BID<BlockSize>&)((*(array[(n) % dim_size]))[(n) / dim_size].bid);
 }
};

BLOCK_ADAPTOR_OPERATORS(runs2bid_array_adaptor)

template <unsigned BlockSize, typename RunType, class PosType = int_type>
struct runs2bid_array_adaptor2
 : public two2one_dim_array_adapter_base<RunType*, BID<BlockSize>, PosType>
{
 typedef runs2bid_array_adaptor2<BlockSize, RunType, PosType> self_type;
 typedef BID<BlockSize> data_type;

 typedef two2one_dim_array_adapter_base<RunType*, BID<BlockSize>, PosType> base_type;

 using base_type::pos;
 using base_type::array;

 enum {
 block_size = BlockSize
 };

 PosType w, h, K;

 runs2bid_array_adaptor2(RunType** a, PosType p, int_type _w, int_type _h)
 : two2one_dim_array_adapter_base<RunType*, BID<BlockSize>, PosType>(a, p),
 w(_w), h(_h), K(_w * _h)
 { }

 runs2bid_array_adaptor2(const self_type& a)
 : two2one_dim_array_adapter_base<RunType*, BID<BlockSize>, PosType>(a),
 w(a.w), h(a.h), K(a.K)
 { }

 const self_type& operator = (const self_type& a)
 {
 array = a.array;
 pos = a.pos;
 w = a.w;
 h = a.h;
 K = a.K;
 return *this;
 }

 data_type& operator * ()
 {
 PosType i = pos - K;
 if (i < 0)
 return (BID<BlockSize>&)((*(array[(pos) % w]))[(pos) / w].bid);

 PosType _w = w;
 _w--;
 return (BID<BlockSize>&)((*(array[(i) % _w]))[h + (i / _w)].bid);
 }

 const data_type* operator -> () const
 {
 PosType i = pos - K;
 if (i < 0)
 return &((*(array[(pos) % w])[(pos) / w].bid));

 PosType _w = w;
 _w--;
 return &((*(array[(i) % _w])[h + (i / _w)].bid));
 }

 data_type& operator [] (PosType n) const
 {
 n += pos;
 PosType i = n - K;
 if (i < 0)
 return (BID<BlockSize>&)((*(array[(n) % w]))[(n) / w].bid);

 PosType _w = w;
 _w--;
 return (BID<BlockSize>&)((*(array[(i) % _w]))[h + (i / _w)].bid);
 }
};

BLOCK_ADAPTOR_OPERATORS(runs2bid_array_adaptor2)

template <typename trigger_iterator_type>
struct trigger_entry_iterator
{
 typedef trigger_entry_iterator<trigger_iterator_type> self_type;
 typedef typename std::iterator_traits<trigger_iterator_type>::value_type::bid_type bid_type;

 // STL typedefs
 typedef bid_type value_type;
 typedef std::random_access_iterator_tag iterator_category;
 typedef int_type difference_type;
 typedef value_type* pointer;
 typedef value_type& reference;

 trigger_iterator_type value;

 trigger_entry_iterator(const self_type& a) : value(a.value) { }
 trigger_entry_iterator(trigger_iterator_type v) : value(v) { }

 bid_type& operator * ()
 {
 return value->bid;
 }
 bid_type* operator -> () const
 {
 return &(value->bid);
 }
 const bid_type& operator [] (int_type n) const
 {
 return (value + n)->bid;
 }
 bid_type& operator [] (int_type n)
 {
 return (value + n)->bid;
 }

 self_type& operator ++ ()
 {
 value++;
 return *this;
 }
 self_type operator ++ (int)
 {
 self_type tmp = *this;
 value++;
 return tmp;
 }
 self_type& operator -- ()
 {
 value--;
 return *this;
 }
 self_type operator -- (int)
 {
 self_type tmp = *this;
 value--;
 return tmp;
 }
 bool operator == (const self_type& a) const
 {
 return value == a.value;
 }
 bool operator != (const self_type& a) const
 {
 return value != a.value;
 }
 self_type operator += (int_type n)
 {
 value += n;
 return *this;
 }
 self_type operator -= (int_type n)
 {
 value -= n;
 return *this;
 }
 int_type operator - (const self_type& a) const
 {
 return value - a.value;
 }
 int_type operator + (const self_type& a) const
 {
 return value + a.value;
 }
};

template <typename Iterator>
inline
trigger_entry_iterator<Iterator>
make_bid_iterator(Iterator iter)
{
 return trigger_entry_iterator<Iterator>(iter);
}

STXXL_END_NAMESPACE

#endif // !STXXL_ALGO_ADAPTOR_HEADER