BlitzArraySliceIterator.h

Go to the documentation of this file.

// Copyright András Vukics 2006–2014. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.txt)
// -*- C++ -*-
#ifndef CPPQEDCORE_UTILS_BLITZARRAYSLICEITERATOR_H_INCLUDED
#define CPPQEDCORE_UTILS_BLITZARRAYSLICEITERATOR_H_INCLUDED

#include "BlitzArraySliceIteratorFwd.h"

#include "BlitzArrayTraits.h"
#include "MultiIndexIterator.h"
#include "TMP_Tools.h"

#include "Exception.h"

#include <boost/mpl/size.hpp>
#include <boost/mpl/sort.hpp>
#include <boost/mpl/unique.hpp>
#include <boost/mpl/max_element.hpp>

#include <boost/range.hpp>

#include <list>



namespace blitzplusplus {


using cpputils::Rank;


namespace basi {

template <typename V> struct Size : boost::mpl::size<V> {};

namespace ttd {

template <int RANK, bool IS_CONST> using ConditionalConstCArray=typename tmptools::ConditionalAddConst<CArray<RANK>,IS_CONST>::type;

template <typename V> using ResCArray=CArray<Size<V>::value>;

template <typename V, bool IS_CONST> using ConditionalConstResCArray=ConditionalConstCArray<Size<V>::value,IS_CONST>;

template <typename I, typename V, bool IS_CONST> using ForwardIteratorHelper=boost::forward_iterator_helper<I,ConditionalConstResCArray<V,IS_CONST> >;

template <int RANK, typename V> using VecIdxTiny=IdxTiny<RANK-Size<V>::value>; 
// note that Array::lbound and ubound return a TinyVector<int,...>, so that here we have to use int as well.

}

using cpputils::mii::Begin; using cpputils::mii::End;



template<int RANK, typename V> struct ConsistencyChecker
{
  static_assert( RANK >= Size<V>::value , "Indexer with nonpositive RANK." );

  typedef typename boost::mpl::sort<V>::type SortedV;
  static_assert( boost::mpl::equal<typename boost::mpl::unique<SortedV,boost::is_same<boost::mpl::_1,boost::mpl::_2> >::type,SortedV>::value , "basi::Iterator inconsistent vector" );
  static_assert( boost::mpl::deref<typename boost::mpl::max_element<V>::type>::type::value < RANK , "basi::Iterator vector out of range" );
};


template<int RANK, int I1, int I2>  struct ConsistencyChecker<RANK,boost::mpl::range_c<int,I1,I2> > { static_assert( I1>=0 && I2<RANK , "basi::Iterator vector out of range" ); };

template<int RANK, int N, int Nbeg> struct ConsistencyChecker<RANK,tmptools::Range<N,Nbeg> > : private ConsistencyChecker<RANK,boost::mpl::range_c<int,Nbeg,Nbeg+N> > {};
template<int RANK, int N>           struct ConsistencyChecker<RANK,tmptools::Ordinals<N>   > : private ConsistencyChecker<RANK,tmptools::  Range  <N,0>             > {};

template<int RANK, typename V>
const ttd::VecIdxTiny<RANK,V>
filterOut(const IdxTiny<RANK>& idx);



//
// The essential part of the work
//


template<int RANK>
class TransposerOrIndexerRankTooHighException : public cpputils::Exception {};

template<int RANK, typename V>
class Transposer
{
public:

  static 
  CArray<RANK>&
  transpose(CArray<RANK>&)
  {throw TransposerOrIndexerRankTooHighException<RANK>();}

};

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"

template<int RANK, typename V>
class Indexer : public Transposer<RANK,V>
{
public:

  static
  ttd::ResCArray<V>&
  index(CArray<RANK>& array, 
        ttd::ResCArray<V>& resArray, 
        const ttd::VecIdxTiny<RANK,V>& idx 
       )
  {throw TransposerOrIndexerRankTooHighException<RANK>();}

};

#pragma GCC diagnostic pop

//
// BlitzArraySliceIterator
//

// Think over: is the following solution based on inheritance to solve the specialization problem optimal?  Note: this is NOT allowed (specialization depending on a template parameter)
// template<typename V, bool IS_CONST> Iterator<Size<V>::value,V,IS_CONST>;

namespace details {

template<typename, bool>
class BaseTrivial;

template<typename, bool>
class BaseSpecial;

template<int, typename, bool>
class Base;

} // details

#define BASE_class boost::mpl::if_c<RANK==1,\
                                    details::BaseTrivial<V,IS_CONST>,\
                                    typename boost::mpl::if_c<RANK==Size<V>::value,\
                                                              details::BaseSpecial<V,IS_CONST>,\
                                                              details::Base<RANK,V,IS_CONST>\
                                                             >::type\
                                   >::type


template<int RANK, typename V, bool IS_CONST>
class Iterator 
  : public ttd::ForwardIteratorHelper<Iterator<RANK,V,IS_CONST>,V,IS_CONST>, // The inheritance has to be public here because of types necessary to inherit
    public BASE_class,
    private ConsistencyChecker<RANK,V>
{
public:
  typedef typename BASE_class Base;

#undef  BASE_class

  typedef typename Base::CcCA CcCA; 

  typedef boost::iterator_range<Iterator> Range; 

  Iterator& operator++() {Base::increment(); return *this;} 


  template<bool IS_END>
  Iterator(CcCA& array, boost::mpl::bool_<IS_END> isEnd) : Base(array,isEnd) {}

};


#define NS_NAME basi
#define RETURN_type1(IS_CONST) Iterator<Rank<A>::value,V_S,IS_CONST>
#define ADDITIONAL_PARAMETER
#define ADDITIONAL_ARGUMENT

#include "details_BlitzArraySliceIteratorReentrant.h"

namespace details {

//
// Base
//

template<int RANK, typename V, bool IS_CONST>
class Base : public Indexer<RANK,V> 
{
public:
  typedef                      CArray<RANK>            CA   ;
  typedef ttd::ConditionalConstCArray<RANK,IS_CONST> CcCA   ;
  typedef ttd::ResCArray<V>                            CARes;
  typedef ttd::ConditionalConstResCArray<V,IS_CONST> CcCARes;

  typedef ttd::VecIdxTiny<RANK,V> VecIdxTiny;

  static const int RANKIDX=RANK-Size<V>::value;

  typedef cpputils::MultiIndexIterator<RANKIDX> Impl;

  Base(CcCA&, Begin); // if it's not the end, it's the beginning
  Base(CcCA&, End  );

  void increment() {++impl_;}

  CcCARes& operator*() const {return Indexer<RANK,V>::index(array_,arrayRes_,*impl_);}
  // This has to return a reference, cf eg. ElementLiovillean::JumpStrategy takes its argument as a non-const reference. Or, it has to take a copy there...

  friend bool operator==(const Base& i1, const Base& i2) {return i1.impl_==i2.impl_ /* && i1.array_==i2.array_ */;}
  // The user has to ensure that the two arrays are actually the same

  const Impl& operator()() const {return impl_;}

private:
  template<bool TAG>
  static Impl ctorHelper(CcCA&);

  mutable CA array_;
  // By value, so that the necessary transposition specified by V can be readily performed. In this case, however, neither stored array can ever be const.

  mutable CARes arrayRes_;

  Impl impl_;

};


//
// BaseTrivial
//

class OutOfRange : public cpputils::Exception {};


template<typename V, bool IS_CONST>
class BaseTrivial
{
public:
  static const int RANK=Size<V>::value;

  typedef                      CArray<RANK>             CA;
  typedef ttd::ConditionalConstCArray<RANK,IS_CONST>  CcCA;

  BaseTrivial(CcCA&, Begin); // if it's not the end, it's the beginning
  BaseTrivial(CcCA&, End  );

  void increment() {if (!isEnd_) isEnd_=true; else throw OutOfRange();}

  CcCA& operator*() const {if (isEnd_) throw OutOfRange(); return array_;}

  friend bool operator==(const BaseTrivial& i1, const BaseTrivial& i2) {return i1.isEnd_==i2.isEnd_;}

protected:
  mutable CA array_;

private:
  bool isEnd_;

};

//
// BaseSpecial
//

template<typename V, bool IS_CONST>
class BaseSpecial : public BaseTrivial<V,IS_CONST>
{
public:
  typedef typename BaseTrivial<V,IS_CONST>::CcCA CcCA;
  
  BaseSpecial(CcCA&, Begin); // if it's not the end, it's the beginning
  BaseSpecial(CcCA&, End  );

};

} // details

} // basi




template<int RANK, typename V>
class SlicesData
{
public:
  typedef std::list<ptrdiff_t> Impl; 

  friend class basi_fast::Iterator<RANK,V, true>;
  friend class basi_fast::Iterator<RANK,V,false>;


  SlicesData(const CArray<RANK>& array);

private:
  static const Impl ctorHelper(const CArray<RANK>&);

  const Impl firstOffsets_;

  const blitz::TinyVector<int      ,basi::Size<V>::value>  shape_;
  const blitz::TinyVector<ptrdiff_t,basi::Size<V>::value> stride_;

  const blitz::GeneralArrayStorage<basi::Size<V>::value> storage_;

};



namespace basi_fast {


template<int RANK, typename V, bool IS_CONST>
class Iterator 
  : public basi::ttd::ForwardIteratorHelper<Iterator<RANK,V,IS_CONST>,V,IS_CONST>
{
public:
  typedef basi::ttd::ConditionalConstCArray<RANK,IS_CONST> CcCA   ;
  typedef basi::ttd::ResCArray<V>                            CARes;
  typedef basi::ttd::ConditionalConstResCArray<V,IS_CONST> CcCARes;

  typedef boost::iterator_range<Iterator> Range;

  Iterator& operator++() {++iter_; return *this;}

  CcCARes& operator*() const 
  {
    arrayRes_.reference(CARes(arrayData_+*iter_,slicesData_.shape_,slicesData_.stride_,blitz::neverDeleteData,slicesData_.storage_));
    return arrayRes_;
  }

  friend bool operator==(const Iterator& i1, const Iterator& i2) {return i1.iter_==i2.iter_;}

  template<bool IS_END>
  Iterator(CcCA& array, const SlicesData<RANK,V>&, boost::mpl::bool_<IS_END> b);

private:
  typename SlicesData<RANK,V>::Impl::const_iterator iter_;

  mutable CARes arrayRes_;

  dcomp*const arrayData_;
  // This can be non_const because the constructor and the dereferencing operator will anyway ensure const-correctness

  const SlicesData<RANK,V>& slicesData_;

};



#define NS_NAME basi_fast
#define RETURN_type1(IS_CONST) Iterator<Rank<A>::value,V_S,IS_CONST>
#define ADDITIONAL_PARAMETER , sd
#define ADDITIONAL_ARGUMENT  , const SlicesData<Rank<A>::value,V_S>& sd

#include "details_BlitzArraySliceIteratorReentrant.h"


} // basi_fast


namespace basi {


template<typename V, typename A>
const Iterator<Rank<A>::value,V,false>
begin(      A& array );

template<typename V, typename A>
const Iterator<Rank<A>::value,V,false>
end  (      A& array );


template<typename V, typename A>
const Iterator<Rank<A>::value,V,true>
begin(const A& array );

template<typename V, typename A>
const Iterator<Rank<A>::value,V,true>
end  (const A& array );


template<typename V, typename A>
const boost::iterator_range<Iterator<Rank<A>::value,V,false> >
fullRange(      A& array );

template<typename V, typename A>
const boost::iterator_range<Iterator<Rank<A>::value,V,true> >
fullRange(const A& array );

} // basi

namespace basi_fast {

template<typename V, typename A>
const Iterator<Rank<A>::value,V,false>
begin(      A& array , const SlicesData<Rank<A>::value,V>& sd);

template<typename V, typename A>
const Iterator<Rank<A>::value,V,true>
begin(const A& array , const SlicesData<Rank<A>::value,V>& sd);

template<typename V, typename A>
const Iterator<Rank<A>::value,V,false>
end  (      A& array , const SlicesData<Rank<A>::value,V>& sd);

template<typename V, typename A>
const Iterator<Rank<A>::value,V,true>
end  (const A& array , const SlicesData<Rank<A>::value,V>& sd);

template<typename V, typename A>
const boost::iterator_range<Iterator<Rank<A>::value,V,true> >
fullRange(const A& array , const SlicesData<Rank<A>::value,V>& sd);

template<typename V, typename A>
const boost::iterator_range<Iterator<Rank<A>::value,V,false> >
fullRange(      A& array , const SlicesData<Rank<A>::value,V>& sd);

} // basi_fast


namespace basi {

} // basi


} // blitzplusplus



#endif // CPPQEDCORE_UTILS_BLITZARRAYSLICEITERATOR_H_INCLUDED