JObjectMultiplexer.hh

Go to the documentation of this file.

#ifndef __JLANG__JOBJECTMULTIPLEXER__
#define __JLANG__JOBJECTMULTIPLEXER__

#include "JLang/JObjectIterator.hh"
#include "JLang/JObjectOutput.hh"
#include "JLang/JValve.hh"
#include "JLang/JTypeList.hh"
#include "JLang/JNullType.hh"
#include "JLang/JBaseClass.hh"
#include "JLang/JSinglePointer.hh"


/**
 * \author mdejong
 */

namespace JLANG {}
namespace JPP { using namespace JLANG; }

namespace JLANG {

  /**
   * Auxiliary class for multiplexing object iterators.
   *
   * The template argument <tt>JDerived_t</tt> refers to a list of 
   * multiple object iterators which are sequentially processed.\n
   * The template argument <tt>JBase_t</tt> refers to a single object iterator
   * which provides for a common interface to the multiple object iterators.
   *
   * This class implements the JLANG::JObjectIterator interface.
   */
  template<class JDerived_t, class JBase_t = typename JBaseClass<JDerived_t>::data_type>
  class JObjectMultiplexer :
    public virtual JObjectIterator<JBase_t>
  {
  public:

    typedef JObjectIterator<JDerived_t>                                 iterator_type;
    typedef typename JObjectIterator<JBase_t>::pointer_type             pointer_type;
    typedef JSinglePointer< JObjectMultiplexer<JDerived_t, JBase_t> >   multiplexer_type;
    typedef JValve<JDerived_t>                                          valve_type;
    

    /**
     * Constructor.
     *
     * \param  input      object iterator
     * \param  valve      valve
     */
    JObjectMultiplexer(iterator_type&    input,
                       const valve_type& valve = valve_type()) :
      valve(valve),
      in(input)
    {}

    
    /**
     * Check availability of next element.
     *
     * \return            true if the valve is open and the iteration has more elements; else false
     */
    virtual bool hasNext() 
    {
      if (valve.is_open())
        return in.hasNext();
      else
        return false;
    }


    /**
     * Get next element.
     *
     * \return            pointer to element
     */
    virtual const pointer_type& next() 
    {
      ps.reset(in.next());
 
      return ps;
    }


    /**
     * Pipe operator.
     *
     * \param  in         object multiplexer
     * \param  out        object output
     */
    friend inline void operator|(JObjectMultiplexer& in, JObjectOutput<JBase_t>& out)
    {
      in >> out;
    }

    valve_type valve;
    
    static multiplexer_type multiplexer;
    
  private:
    iterator_type& in;
    pointer_type   ps;
  };

  /**
   * Multiplexer.
   */
  template<class JDerived_t, class JBase_t>
  JSinglePointer< JObjectMultiplexer<JDerived_t, JBase_t> >
  JObjectMultiplexer<JDerived_t, JBase_t>::multiplexer;

  
  /**
   * Template specialisation of JObjectMultiplexer for multiple object iterators.
   * Implementation of object multiplexing for multiple data types.
   *
   * This class recursively extends the JLANG::JObjectMultiplexer class 
   * for all data types by deriving from:
   *  - JObjectMultiplexer<JHead_t, JBase_t>; and
   *  - JObjectMultiplexer<JTail_t, JBase_t>.
   *
   * This class implements the JLANG::JObjectIterator interface.
   */
  template<class JHead_t, class JTail_t, class JBase_t>
  class JObjectMultiplexer<JTypeList<JHead_t, JTail_t>, JBase_t> :
    public JObjectMultiplexer<JHead_t, JBase_t>,
    public JObjectMultiplexer<JTail_t, JBase_t>,
    public virtual JObjectIterator<JBase_t>
  {
  public:

    typedef JTypeList<JHead_t, JTail_t>                                 typelist;
    typedef JObjectIterator<typelist>                                   iterator_type;
    typedef typename JObjectIterator<JBase_t>::pointer_type             pointer_type;
    typedef JSinglePointer< JObjectMultiplexer<typelist, JBase_t> >     multiplexer_type;
    typedef JValve<typelist>                                            valve_type;

      
    /**
     * Constructor.
     *
     * \param  input      object iterator
     * \param  valve      valve
     */
    JObjectMultiplexer(iterator_type&    input,
                       const valve_type& valve = valve_type()) :
      JObjectMultiplexer<JHead_t, JBase_t>(input, valve),
      JObjectMultiplexer<JTail_t, JBase_t>(input, valve)
    {}

    
    /**
     * Check availability of next element.
     *
     * \return            true if the iteration has more elements; else false
     */
    virtual bool hasNext() 
    {
      return (JObjectMultiplexer<JHead_t, JBase_t>::hasNext() ||
              JObjectMultiplexer<JTail_t, JBase_t>::hasNext());
    }


    /**
     * Get next element.
     *
     * \return            pointer to element
     */
    virtual const pointer_type& next() 
    {
      if (JObjectMultiplexer<JHead_t, JBase_t>::hasNext())
        ps.reset(JObjectMultiplexer<JHead_t, JBase_t>::next());
      else
        ps.reset(JObjectMultiplexer<JTail_t, JBase_t>::next());

      return ps;
    }


    /**
     * Pipe operator.
     *
     * \param  in         object multiplexer
     * \param  out        object output
     */
    friend inline void operator|(JObjectMultiplexer& in, JObjectOutput<JBase_t>& out)
    {
      in >> out;
    }
    
    static multiplexer_type multiplexer;

  private:
    pointer_type ps;
  };
  
  /**
   * Multiplexer.
   */
  template<class JHead_t, class JTail_t, class JBase_t>
  JSinglePointer< JObjectMultiplexer<JTypeList<JHead_t, JTail_t>, JBase_t> >
  JObjectMultiplexer<JTypeList<JHead_t, JTail_t>, JBase_t>::multiplexer;

    
  /**
   * Terminator class of recursive JObjectMultiplexer class.
   */
  template<class JHead_t, class JBase_t>
  class JObjectMultiplexer<JTypeList<JHead_t, JNullType>, JBase_t> :
    public JObjectMultiplexer<JHead_t, JBase_t>
  {
  public:

    typedef JObjectIterator<JHead_t>                                    iterator_type;
    typedef typename JObjectIterator<JBase_t>::pointer_type             pointer_type;
    typedef JSinglePointer< JObjectMultiplexer<JHead_t, JBase_t> >      multiplexer_type;
    typedef JValve<JHead_t>                                             valve_type;

    
    /**
     * Constructor.
     *
     * \param  input      object iterator
     * \param  valve      valve
     */
    JObjectMultiplexer(iterator_type&    input,
                       const valve_type& valve = valve_type()) :
      JObjectMultiplexer<JHead_t, JBase_t>(input, valve)
    {}
  };
}

#endif