foreach.h

Go to the documentation of this file.

#ifndef CXXTLS_FOREACH_H_INCLUDED
#define CXXTLS_FOREACH_H_INCLUDED

namespace cxxtls
{
namespace foreach_helpers
{

typedef unsigned long long size_t;

// note:  std::set::iterator::operator*() returns a const reference, 
// instead of a mutable reference like all other containers do.
// sooo, we have to figure out what the constness of the *iterator is
// whenever we dereference the the loop iterators.

template<class Container>
struct iteratorReturnsConst
{
    // Container must have an iterator member type

    typedef typename Container::iterator Iterator;  

    template<class U>  
    static char is_const_tester(const U &);   // takes only const params

    template<class V>
    static int  is_const_tester(V &); // takes any parameter type 

    static Iterator it;  // never gets instantiated

    enum c {
              value = (
                         sizeof(char) == sizeof(
                                                 is_const_tester(*it) 
                                               )
                      )
           };
};



template<bool, class ZeroClass, class OneClass> 
struct  EvalTypeIf
{
};

template<class ZeroClass, class OneClass> 
struct  EvalTypeIf<0, ZeroClass, OneClass>
{
  typedef ZeroClass type;  // the false case:
};

template<class ZeroClass, class OneClass> 
struct  EvalTypeIf<1, ZeroClass, OneClass>
{
  typedef OneClass type;  // the true case
};

template<class Container>
struct IteratorReferent
{
    typedef typename EvalTypeIf<  iteratorReturnsConst<Container>::value, 
                                  typename Container::value_type, 
                                  const typename Container::value_type
                               >::type
            type;
};

template<class Container, size_t N>
struct IteratorReferent<Container [N]>
   // see above
{
    typedef Container type;
};

template<class Container, size_t N>
struct IteratorReferent<const Container [N]>
   // see above
{
    typedef const Container type;
};


struct AnyTypeBase
  //
  //  References to objects of AnyTypeBase will be cast to references to
  //  objects of type AnyType<T>, where T is defined externally to
  //  AnyType or their uses.
  //
{
   operator bool() const { return 0; }
};

template<class T>
struct AnyType
    //
    //  A wrapper around any type.  Sometimes T is a reference and sometimes
    //  it is a real value.
    //
: public AnyTypeBase
{
   typedef T value_type;

   mutable T value_;

   AnyType(T t)
   : value_(t)
   {
   }

};

template<class T>
struct IteratorWrapper
   //
   //  An object that can hold any kind of iterator.  The template parameter
   //  T refers to the STL style container whose iterator is being held.
   //
   //  There is a template specialization below that handles arrays.
   //
{
   typename T::iterator iterator_;

   IteratorWrapper(typename T::iterator t)
   : iterator_(t)
   {
   }

   typename IteratorReferent<T>::type &operator*() { return *iterator_; }

   typename T::value_type const &operator*() const { return *iterator_; }

};

template<class T>
struct IteratorWrapper<T *>
{
   T* iterator_;

   IteratorWrapper(T const * t)
   : iterator_(const_cast<T*>(t))
   {
   }

   T &operator*() { return *iterator_; }

   T const &operator*() const { return *iterator_; }

};


template<class T>
inline
AnyType< T & > 
getContainer(T const& v) 
    



{ 
    return const_cast<T&>(v) ; 
} 

template<class T, size_t N>
inline
AnyType< T const* > 
getContainer(T const (&v)[N]) 
    



{ 
    T (&array)[N] = const_cast< T (&)[N] >(v); 

    return &array[0];
} 


template<class T>
inline
AnyType< IteratorWrapper<T> >
getBegin(AnyTypeBase const &b, T const *) 
    






{ 
    AnyType< T& > const &container = static_cast< AnyType<T&> const& > (b);

    return IteratorWrapper<T>(container.value_.begin());

}


template<class T, size_t N>
inline
AnyType< IteratorWrapper<T*> >
getBegin(AnyTypeBase const &b, T const (*)[N]) 
    






{
    AnyTypeBase &mutableBase = const_cast<AnyTypeBase&>(b);

    AnyType< T const* > const &container = static_cast< AnyType< T const* > &> (mutableBase);

    return IteratorWrapper<T*>(container.value_);

}


template<class T>
inline
AnyType< IteratorWrapper<T> > 
getEnd(AnyTypeBase const &b, T const *) 
    






{ 
    AnyType< T& > const &container = static_cast< AnyType<T&> const& > (b);

    return IteratorWrapper<T>(container.value_.end());
}

template<class T, size_t N>
inline
AnyType< IteratorWrapper<T*> >
getEnd(AnyTypeBase const &b, T const (*)[N]) 
    






{
    AnyTypeBase &mutableBase = const_cast<AnyTypeBase&>(b);

    AnyType< T const* > const &container = static_cast< AnyType< T const* > &> (mutableBase);

    return IteratorWrapper<T*>(container.value_ + N);

}



template<class Container>
inline typename IteratorReferent<Container>::type
&deref(AnyTypeBase const & current, Container *)
{
    typedef IteratorWrapper<Container> IteratorType;

    AnyType<IteratorType> const &cur = static_cast<AnyType<IteratorType> const &>(current);

    // cur is a const reference to an AnyType which declares its member to be mutable

    typename Container::value_type const &cref =  *cur.value_;

    return const_cast< typename IteratorReferent<Container>::type &>(cref);
}

template<class Container>
inline
const typename Container::value_type &deref(AnyTypeBase const & current,
                                      Container const *
                                     )
{
    AnyType< IteratorWrapper<Container> > const &cur = 
                                               static_cast<AnyType< IteratorWrapper<Container> > const &>(current);

    // cur is a const reference to an AnyType which declares its member to be mutable

    return *cur.value_;
}


template<class T, size_t N>
inline
T const &deref(AnyTypeBase const & current,
          T const (*)[N]
         )
{
    AnyType< IteratorWrapper<T*> > const &cur = 
                                               static_cast< AnyType< IteratorWrapper<T*> > const &>(current);

    // cur is a const reference to an AnyType which declares its member to be mutable

    return *cur.value_;
}

template<class T, size_t N>
inline
T  &deref(AnyTypeBase const & current,
          T (*)[N]
         )
{
    AnyType< IteratorWrapper<T*> > const &cur = 
                                               static_cast< AnyType< IteratorWrapper<T*> > const &>(current);

    // cur is a const reference to an AnyType which declares its member to be mutable

    return *cur.value_;
}



template<class Container>
inline
bool continuing(AnyTypeBase const &current, AnyTypeBase const &last, Container const *)
{
    AnyType< IteratorWrapper<Container> > const &cur = 
                                               static_cast<AnyType<IteratorWrapper<Container> > const &>(current);

    AnyType< IteratorWrapper<Container> > const &end = 
                                               static_cast<AnyType< IteratorWrapper<Container>  > const &>(last);

   return cur.value_.iterator_ != end.value_.iterator_;
}


template<class T, size_t N>
inline
bool continuing(AnyTypeBase const &current, AnyTypeBase const &last, T const (*)[N])
{
    AnyType< IteratorWrapper<T*> > const &cur = 
                                               static_cast<AnyType<IteratorWrapper<T*> > const &>(current);

    AnyType< IteratorWrapper<T*> > const &end = 
                                               static_cast<AnyType< IteratorWrapper<T*>  > const &>(last);

   return cur.value_.iterator_ != end.value_.iterator_;
}

            
template<class Container>
inline
bool next(AnyTypeBase const &current, AnyTypeBase const &last, Container const *)
{

    AnyType< IteratorWrapper<Container> > const &cur = 
                                               static_cast<AnyType< IteratorWrapper<Container> > const &>(current);

    AnyType< IteratorWrapper<Container> > const &end = 
                                               static_cast<AnyType< IteratorWrapper<Container> > const &>(last);

    if(cur.value_.iterator_ != end.value_.iterator_)
    {
       ++cur.value_.iterator_;
    }
    else
    {
       throw AnyType<int>(0); // no can do big guy -- end of list
    }

    return true;
}

template<class T, size_t N>
inline
bool next(AnyTypeBase const &current, AnyTypeBase const &last, T const (*)[N])
{

    AnyType< IteratorWrapper<T*> > const &cur = 
                                               static_cast<AnyType< IteratorWrapper<T*> > const &>(current);

    AnyType< IteratorWrapper<T*> > const &end = 
                                               static_cast<AnyType< IteratorWrapper<T*> > const &>(last);

    if(cur.value_.iterator_ != end.value_.iterator_)
    {
       ++cur.value_.iterator_;
    }
    else
    {
       throw AnyType<int>(0); // no can do big guy -- end of list
    }

    return true;

}


} // namespace foreach_helpers
} // namespace cxxtls


#define CXXTLS_NULL_TYPE_PTR(bag) \
   (true?0 : &bag)


#define CXXTLS_FENS(n)  cxxtls::foreach_helpers::n


#define CXXTLS_FEV(n)   cxxtls_foreach_var_##n



#if 0
// my original logic

#define CXXTLS_FOREACH(loopVar, bag)                                                           \
    if( CXXTLS_FENS(AnyTypeBase) const & CXXTLS_FEV(cnt) =                                     \
         CXXTLS_FENS(getContainer)(bag) )                                              {} else \
    if( CXXTLS_FENS(AnyTypeBase) const & CXXTLS_FEV(cur) =                                     \
         CXXTLS_FENS(getBegin)(CXXTLS_FEV(cnt), CXXTLS_NULL_TYPE_PTR(bag)))            {} else \
    if( CXXTLS_FENS(AnyTypeBase) const &  CXXTLS_FEV(end) =                                    \
         CXXTLS_FENS(getEnd)(CXXTLS_FEV(cnt), CXXTLS_NULL_TYPE_PTR(bag)))              {} else \
    for( bool done=false;                                                                      \
         CXXTLS_FENS(continuing)(CXXTLS_FEV(cur), CXXTLS_FEV(end), CXXTLS_NULL_TYPE_PTR(bag)); \
         done=false                                                                            \
       )                                                                                       \
    for( loopVar = CXXTLS_FENS(deref)( CXXTLS_FEV(cur), CXXTLS_NULL_TYPE_PTR(bag));            \
         !done;                                                                                \
         (done=true) &&                                                                        \
             CXXTLS_FENS(next)(CXXTLS_FEV(cur), CXXTLS_FEV(end), CXXTLS_NULL_TYPE_PTR(bag))    \
       )
#endif


// logic tweaked by comparison of the for loops at the bottom with boost to overcome the
// bug that prevented break from working inside the loop.

#define CXXTLS_FOREACH(loopVar, bag)                                                           \
    if( CXXTLS_FENS(AnyTypeBase) const & CXXTLS_FEV(cnt) =                                     \
         CXXTLS_FENS(getContainer)(bag) )                                              {} else \
    if( CXXTLS_FENS(AnyTypeBase) const & CXXTLS_FEV(cur) =                                     \
         CXXTLS_FENS(getBegin)(CXXTLS_FEV(cnt), CXXTLS_NULL_TYPE_PTR(bag)))            {} else \
    if( CXXTLS_FENS(AnyTypeBase) const &  CXXTLS_FEV(end) =                                    \
         CXXTLS_FENS(getEnd)(CXXTLS_FEV(cnt), CXXTLS_NULL_TYPE_PTR(bag)))              {} else \
    for( bool fcCnTiNuE=true;                                                                 \
         fcCnTiNuE && CXXTLS_FENS(continuing)(CXXTLS_FEV(cur), CXXTLS_FEV(end), CXXTLS_NULL_TYPE_PTR(bag)); \
         (fcCnTiNuE? CXXTLS_FENS(next)(CXXTLS_FEV(cur), CXXTLS_FEV(end), CXXTLS_NULL_TYPE_PTR(bag)) : 0 )   \
       )                                                                                       \
    if((fcCnTiNuE=false)) {} else                                                             \
    for( loopVar = CXXTLS_FENS(deref)( CXXTLS_FEV(cur), CXXTLS_NULL_TYPE_PTR(bag));            \
         !fcCnTiNuE;                                                                          \
         fcCnTiNuE=true                                                                       \
       )



#endif