Tree_LRP.h

Ir a la documentación de este archivo.

// Tree_LRP.h     (c) 2009 walter_wabe@yahoo.com

#ifdef English_dox
/// \file   Tree_LRP.h
/// \brief  Left-Right-Process iterator.
/// \author Walter Wabe Acuña <walter_wabe@yahoo.com>
/// \author Adolfo Di Mare <adolfo@di-mare.com>
/// \date   2009
///
#endif
#ifdef Spanish_dox
/// \file   Tree_LRP.h
/// \brief  Iterador Izquierda-Derecha-Proceso.
/// \author Walter Wabe Acuña <walter_wabe@yahoo.com>
/// \author Adolfo Di Mare <adolfo@di-mare.com>
/// \date   2009
///
#endif

#ifndef Tree_LRP_h
#define Tree_LRP_h

#ifdef English_dox
    /// Doxygen English documentation.
    #define English_dox   "Doxygen English documentation"
   /// \def English_dox  ///< Marks English documentation blocks.
   /// \def Tree_LRP_h   ///< Avoids multiple inclusion.
#endif
#ifdef Spanish_dox
    /// Documentaci¢n en espa¤ol.
    #define Spanish_dox "Documentaci¢n Doxygen en espa¤ol"
   /// \def Spanish_dox  ///< Macro usado para que Doxygen genere documentación.
   /// \def Tree_LRP_h   ///< Evita la inclusión múltiple.
#endif

#include <list>
#include "Tree_L.h"
#include <iostream>

#ifdef English_dox
/// Left-Right-Process iterator.
#endif
#ifdef Spanish_dox
/// Iterador Izquierda-Derecha-Proceso.
#endif
/**
    \dontinclude test_iterJava.cpp
    \skipline    test::Tree_LRP()
    \until       }}
    \see         test_iterJava::test_Tree_LRP()

    \see         make_a_o(TL::Tree<char> & T)
    \dontinclude test_iterJava.cpp
    \skipline    T = a
    \until       +--k
*/

template <typename E>
class Tree_LRP {
    std::list< TL::Tree<E> > m_Q; ///< std::queue<>.
public:
    /// \c init().
    Tree_LRP( const TL::Tree<E>& T = TL::Tree<E>() )
     :   m_Q() { set(T); }
     void set( const TL::Tree<E>& T ); ///< \c Iterator::set().

    bool  hasNext() const;    ///< \c Iterator::hasNext().
    const TL::Tree<E> next(); ///< \c Iterator::next().
};

template <typename E>
void Tree_LRP<E>::set( const TL::Tree<E>& T ) {
    m_Q.clear(); // erase whatever was left
    if ( T.Empty() ) {
        return;
    }
    TL::Tree<E> Child = T.Root();
    while ( !Child.Leftmost().Empty() ) {
        Child = Child.Leftmost();
    }
    while ( !Child.Empty() ) {
        m_Q.push_back(Child);
    //  std::cout << Child.Data();
        if ( !Child.Right_Sibling().Empty() ) {
            Child = Child.Right_Sibling();
            while ( !Child.Leftmost().Empty() ) {
                Child = Child.Leftmost();
            }
        }
        else {
            while ( !Child.Father().Empty()
                      &&
                  ( Child==Child.Father().Right_Sibling() )
            ) {
                Child = Child.Father();
            }
            Child = Child.Father();
        }
    }
}

/* Indicates if the iterator have a next element */
template <typename E>
bool Tree_LRP<E>::hasNext() const {
    return ( ! m_Q.empty() );
}

/* Moves the iterator to it`s next element */
template <typename E>
const TL::Tree<E> Tree_LRP<E>::next() {
    TL::Tree<E> first = m_Q.front();
    m_Q.pop_front();
    return first;
}

#endif //  Tree_LRP_h
//  EOF: Tree_LRP.h