10     class TransformIterValProxy{
 
   12         typedef const T & reference;
 
   13         typedef const T * pointer;
 
   16         reference getRef(
const T & functionReturn){
 
   20         pointer getPr(
const T & functionReturn){
 
   30     class TransformIterValProxy<const T &>{
 
   31         typedef const T & reference;
 
   32         typedef const T * pointer;
 
   35         reference getRef(
const T & functionReturn){
 
   39         pointer getPr(
const T & functionReturn){
 
   48     class TransformIterValProxy<T &>{
 
   49         typedef T & reference;
 
   53         reference getRef(
const T & functionReturn){
 
   57         pointer getPr(
const T & functionReturn){
 
   70     class TransformIterator{
 
   74         typedef typename UnaryFunction::result_type function_result_type;
 
   75         typedef TransformIterValProxy<function_result_type> RetHelper;
 
   77         typedef typename RetHelper::value_type  value_type;
 
   78         typedef typename RetHelper::reference   reference;
 
   79         typedef typename RetHelper::pointer     pointer;
 
   81         typedef typename std::iterator_traits<Iterator>::difference_type    difference_type;
 
   82         typedef typename std::iterator_traits<Iterator>::iterator_category iterator_category;
 
   84         TransformIterator(
const Iterator & iter = Iterator(), 
const UnaryFunction & f = UnaryFunction())
 
   89         reference  operator * ()
 const{
 
   90             return retHelper_.getRef(f_(*iter_)); 
 
   93         reference  operator[](
const difference_type i)
 const{
 
   94             return retHelper_.getRef(f_(iter_[i])); 
 
   97         pointer  operator -> ()
 const{
 
   98             return retHelper_.getRef(f_(*iter_)); 
 
  102         #define TRANSFORMITERATOR_CP_OP_GEN(OP)\ 
  103         bool operator OP (const TransformIterator & rhs)const{\ 
  104             return iter_ OP rhs.iter_;\ 
  107         TRANSFORMITERATOR_CP_OP_GEN(==);
 
  108         TRANSFORMITERATOR_CP_OP_GEN(!=);
 
  109         TRANSFORMITERATOR_CP_OP_GEN(<);
 
  110         TRANSFORMITERATOR_CP_OP_GEN(<=);
 
  111         TRANSFORMITERATOR_CP_OP_GEN(>);
 
  112         TRANSFORMITERATOR_CP_OP_GEN(>=);
 
  114         #undef TRANSFORMITERATOR_CP_OP_GEN 
  116         TransformIterator & operator ++ (){
 
  120         TransformIterator & operator -- (){
 
  124         TransformIterator operator ++ (
int)
 const{
 
  125             TransformIterator res(*
this);
 
  129         TransformIterator operator -- (
int)
const{
 
  130             TransformIterator res(*
this);
 
  134         TransformIterator & 
operator+=( 
const difference_type i ){
 
  138         TransformIterator & 
operator-=( 
const difference_type i ){
 
  142         TransformIterator 
operator+( 
const difference_type i )
const{
 
  143             TransformIterator res(*
this);
 
  147         TransformIterator 
operator-( 
const difference_type i )
const{
 
  148             TransformIterator res(*
this);
 
  153         difference_type 
operator - (
const TransformIterator rhs)
 const{
 
  154             return iter_ - rhs.iter_;
 
  158         const Iterator & baseIterator()
const{
 
  161         const UnaryFunction & unaryFunction()
const{
 
  167         mutable RetHelper retHelper_;
 
  175     class EndAwareTransformIterator
 
  176     : 
public TransformIterator<UnaryFunction, Iterator>
 
  179         EndAwareTransformIterator(
const Iterator & iter = Iterator(), 
const UnaryFunction & f = UnaryFunction())
 
  180         :   TransformIterator<UnaryFunction, Iterator>(iter,f){
 
  183         EndAwareTransformIterator getEndIterator()
const{
 
  184             return EndAwareTransformIterator(this->baseIterator().getEndIterator(),
 
  185                                              this->unaryFunction());
 
Diff2D operator-(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:711
Diff2D operator+(Diff2D const &a, Diff2D const &b)
Definition: diff2d.hxx:739
FFTWComplex< R > & operator-=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
subtract-assignment 
Definition: fftw3.hxx:867
FFTWComplex< R > & operator+=(FFTWComplex< R > &a, const FFTWComplex< R > &b)
add-assignment 
Definition: fftw3.hxx:859