JObjectIterator.hh

Go to the documentation of this file.

#ifndef __JLANG__JOBJECTITERATOR__
#define __JLANG__JOBJECTITERATOR__
 
#include "JLang/JType.hh"
#include "JLang/JTypeList.hh"
#include "JLang/JNullType.hh"
#include "JLang/JPointer.hh"
#include "JLang/JSinglePointer.hh"
#include "JLang/JRewindable.hh"
#include "JLang/JAccessible.hh"
 
 
/**
 * \author mdejong
 */
 
namespace JLANG {}
namespace JPP { using namespace JLANG; }
 
namespace JLANG {
 
  /**
   * Type definition for number of objects to skip.
   */
  typedef unsigned int    skip_type;
 
 
  /**
   * \cond NEVER
   * Forward declarations for definitions of I/O redirect and pipe operators.
   * \endcond
   */
  template<class T> class JObjectOutput;
  template<class T> class JValve;
  template<class T> class JObjectSelector;
  class JRegulator;
  template<class JDerived_t, class JBase_t> class JObjectMultiplexer;
  template<class T, int N> class JMultiPipe;
    
 
  /**
   * Interface of object iteration for a single data type.
   */
  template<class T>
  class JObjectIterator {
  protected:
    /**
     * Default constructor.
     */
    JObjectIterator()
    {}
 
 
  public:
    /**
     * Type definition of pointer_type.
     */
    typedef JPointer<T>                    pointer_type;
 
    
    /**
     * Virtual destructor.
     */
    virtual ~JObjectIterator()
    {}
 
 
    /**
     * Check availability of next element.
     *
     * \return            true if the iteration has more elements; else false
     */
    virtual bool hasNext() = 0;
 
 
    /**
     * Get next element.
     *
     * \return            pointer to element
     */
    virtual const pointer_type& next() = 0;
 
 
    /**
     * Skip items.
     *
     * \param  ns         number of items to skip
     * \return            number of items skipped
     */
    virtual skip_type skip(const skip_type ns) 
    {
      skip_type i = 0;
 
      for ( ; i != ns && hasNext(); ++i) {
        next();
      }
 
      return i;
    }
 
 
    /**
     * Copy to object output.
     * 
     * \param  in         object iterator
     * \param  out        object output
     * \return            object iterator
     */                                                                 
    friend inline JObjectIterator<T>& operator>>(JObjectIterator<T>& in,
                                                 JObjectOutput  <T>& out)
    {
      while (in.hasNext()) {
 
        const T* p = in.next();
 
        if (p != NULL)
          out.put(*p);
        else
          break; 
      }
 
      return in;
    }
 
 
    /**
     * Pipe terminator.
     *
     * \param  left       object iterator
     * \param  right      object output
     */
    friend inline void operator|(JObjectIterator<T>& left, JObjectOutput<T>& right)
    {
      left >> right;
    }
 
 
    /**
     * Pipe operator.
     * 
     * \param  left       object iterator
     * \param  right      valve
     * \return            pipe object
     */                                                                 
    friend inline JMultiPipe<T,0>& operator|(JObjectIterator<T>& left, const JValve<T>& right)
    {
      JMultiPipe<T,0>::pipe.reset(new JMultiPipe<T,0>(left, right));
 
      return *JMultiPipe<T,0>::pipe;
    }
 
 
    /**
     * Pipe operator.
     * 
     * \param  left       object iterator
     * \param  right      object selector
     * \return            pipe object
     */
    friend inline JMultiPipe<T,0>& operator|(JObjectIterator<T>& left, const JObjectSelector<T>& right)
    {
      JMultiPipe<T,0>::pipe.reset(new JMultiPipe<T,0>(left, right));
 
      return *JMultiPipe<T,0>::pipe;
    }
 
 
    /**
     * Pipe operator.
     * 
     * \param  left       object iterator
     * \param  right      regulator
     * \return            pipe object
     */
    friend inline JMultiPipe<T,0>& operator|(JObjectIterator<T>& left, const JRegulator& right)
    {
      JMultiPipe<T,0>::pipe.reset(new JMultiPipe<T,0>(left, right));
 
      return *JMultiPipe<T,0>::pipe;
    }
    
 
    /**
     * Pipe operator.
     * 
     * \param  left       object iterator
     * \param  right      data type
     * \return            object multiplexer
     */                                                                 
    template<class JBase_t>
    friend inline JObjectMultiplexer<T, JBase_t>& operator|(JObjectIterator<T>& left, const JType<JBase_t>& right)
    {
      JObjectMultiplexer<T, JBase_t>::multiplexer.reset(new JObjectMultiplexer<T, JBase_t>(left));
 
      return *JObjectMultiplexer<T, JBase_t>::multiplexer;
    }
  };
 
 
  /**
   * Implementation of object iterator for multiple data types.
   *
   * This class recursively defines the JLANG::JObjectIterator interface
   * for all data types by deriving from:
   *  - JObjectIterator<JHead_t>; and 
   *  - JObjectIterator<JTail_t>.
   */
  template<class JHead_t, class JTail_t>
  class JObjectIterator< JTypeList<JHead_t, JTail_t> > :
    public virtual JObjectIterator<JHead_t>,
    public virtual JObjectIterator<JTail_t>
  {
  public:
 
    typedef JTypeList<JHead_t, JTail_t>  typelist;
    
    /**
     * Copy to object output.
     *
     * Note that all data types of the input are copied to the output.
     *
     * \param  in         object iterator
     * \param  out        object output
     * \return            object iterator
     */
    template<class JOutputIterator_t>
    friend inline JObjectIterator& operator>>(JObjectIterator<typelist>& in, JOutputIterator_t& out)
    {
      static_cast<JObjectIterator<JHead_t>&>(in) >> static_cast<JObjectOutput<JHead_t>&>(out);
      static_cast<JObjectIterator<JTail_t>&>(in) >> out;
 
      return in;
    }
 
 
    /**
     * Pipe terminator.
     *
     * \param  left       object iterator
     * \param  right      object output
     */
    friend inline void operator|(JObjectIterator<typelist>& left, JObjectOutput<typelist>& right)
    {
      left >> right;
    }
 
 
    /**
     * Pipe operator.
     * 
     * \param  left       object iterator
     * \param  right      valve
     * \return            pipe object
     */                                                                 
    friend inline JMultiPipe<typelist,0>&
    operator|(JObjectIterator<typelist>& left, const JValve<typelist>& right)
    {
      JMultiPipe<typelist,0>::pipe.reset(new JMultiPipe<typelist,0>(left, right));
 
      return *JMultiPipe<typelist,0>::pipe;
    }
 
 
    /**
     * Pipe operator.
     * 
     * \param  left       object iterator
     * \param  right      object selector
     * \return            pipe object
     */                                                                 
    friend inline JMultiPipe<typelist,0>&
    operator|(JObjectIterator<typelist>& left, const JObjectSelector<typelist>& right)
    {
      JMultiPipe<typelist,0>::pipe.reset(new JMultiPipe<typelist,0>(left, right));
 
      return *JMultiPipe<typelist,0>::pipe;
    }
 
 
    /**
     * Pipe operator.
     * 
     * \param  left       object iterator
     * \param  right      regulator
     * \return            pipe object
     */                                                                 
    friend inline JMultiPipe<typelist,0>&
    operator|(JObjectIterator<typelist>& left, const JRegulator& right)
    {
      JMultiPipe<typelist,0>::pipe.reset(new JMultiPipe<typelist,0>(left, right));
 
      return *JMultiPipe<typelist,0>::pipe;
    }
    
 
    /**
     * Pipe operator.
     * 
     * \param  left       object iterator
     * \param  right      data type
     * \return            object multiplexer
     */                                                                 
    template<class JBase_t>
    friend inline JObjectMultiplexer<typelist, JBase_t>&
    operator|(JObjectIterator<typelist>& left, const JType<JBase_t>& right)
    {
      JObjectMultiplexer<typelist, JBase_t>::multiplexer.reset(new JObjectMultiplexer<typelist, JBase_t>(left));
 
      return *JObjectMultiplexer<typelist, JBase_t>::multiplexer;
    }
  };
 
 
  /**
   * Terminator class of recursive JObjectIterator class.
   */
  template<class JHead_t>
  class JObjectIterator< JTypeList<JHead_t, JNullType> > :
    public virtual JObjectIterator<JHead_t>
  {};
 
 
  /**
   * Implementation for null iteration.
   */
  template<class T>
  struct JNullIterator :
    public virtual JObjectIterator<T>
  {
 
    typedef typename JObjectIterator<T>::pointer_type  pointer_type;
 
    
    /**
     * Check availability of next element.
     *
     * \return            false
     */
    virtual bool hasNext() 
    {
      return false;
    }
 
 
    /**
     * Get next element.
     *
     * \return            NULL
     */
    virtual const pointer_type& next() 
    {
      return ps;
    }
 
  private:
    pointer_type ps;
  };
 
 
  /**
   * Interface for object iteration with rewinding.
   */
  template<class T>
  class JRewindableObjectIterator :
    public virtual JObjectIterator<T>,
    public virtual JRewindable    <T>
  {};
 
 
  /**
   * Interface for object iteration with named access.
   */
  template<class T>
  class JAccessibleObjectIterator :
    public virtual JObjectIterator<T>,
    public virtual JAccessible
  {};
}
 
#endif