IteratorImpl.h

Go to the documentation of this file.

/* -*- C++ -*- */
#ifndef _MADARA_TREE_ITERATOR_IMPL_H_
#define _MADARA_TREE_ITERATOR_IMPL_H_

#include <stdlib.h>
#include <stdexcept>

#include "madara/utility/LStack.h"
#include "madara/utility/LQueue.h"
#include "madara/knowledge/KnowledgeRecord.h"

namespace madara
{
  namespace utility
  {
    template <typename T>
    class Refcounter;
  }

  namespace expression
  {
    class ComponentNode;
    class ExpressionTreeIterator;
    class ExpressionTree;

    class ExpressionTreeIteratorImpl
    {
      friend class ExpressionTreeIterator;

    public:
      ExpressionTreeIteratorImpl (const ExpressionTree &tree);

      virtual ~ExpressionTreeIteratorImpl (void);

      virtual ExpressionTree operator* (void) = 0;

      virtual const ExpressionTree operator* (void) const = 0;

      virtual void operator++ (void) = 0;

      virtual bool operator== (const ExpressionTreeIteratorImpl &rhs)
        const = 0;

      virtual bool operator!= (const ExpressionTreeIteratorImpl &rhs)
        const = 0;

      virtual ExpressionTreeIteratorImpl *clone(void) = 0;

      typedef ::std::forward_iterator_tag iterator_category;
      typedef madara::knowledge::KnowledgeRecord value_type;
      typedef int *pointer;
      typedef int &reference;
      typedef int difference_type;

    protected:
      const ExpressionTree &tree_;
    };

    class InOrderIteratorImpl : public ExpressionTreeIteratorImpl
    {
      friend class ExpressionTreeIterator;
      friend class utility::Refcounter<ExpressionTreeIteratorImpl>;
    public:
      InOrderIteratorImpl (const ExpressionTree &tree,
                                   bool end_iter = false);

      virtual ~InOrderIteratorImpl (void);

      virtual ExpressionTree operator* (void);

      virtual const ExpressionTree operator* (void) const;

      virtual void operator++ (void);

      virtual bool operator== (const ExpressionTreeIteratorImpl &rhs)
        const;

      virtual bool operator!= (const ExpressionTreeIteratorImpl &lhs)
        const;

      virtual ExpressionTreeIteratorImpl *clone (void);

      // = Necessary traits
      typedef ::std::forward_iterator_tag iterator_category;
      typedef madara::knowledge::KnowledgeRecord value_type;
      typedef int *pointer;
      typedef int &reference;
      typedef int difference_type;

    private:
      madara::utility::LStack <ExpressionTree> stack_;
    };

    class PreOrderIteratorImpl : public ExpressionTreeIteratorImpl
    {
      friend class ExpressionTreeIterator;
      friend class utility::Refcounter<ExpressionTreeIteratorImpl>;

    public:
      PreOrderIteratorImpl (const ExpressionTree &tree, 
                                    bool end_iter = false);

      virtual ~PreOrderIteratorImpl ();

      virtual ExpressionTree operator* (void);

      virtual const ExpressionTree operator* (void) const;

      virtual void operator++ (void);

      virtual bool operator== (const ExpressionTreeIteratorImpl &rhs)
        const;

      virtual bool operator!= (const ExpressionTreeIteratorImpl &lhs)
        const;

      virtual ExpressionTreeIteratorImpl *clone (void);

      // = Necessary traits
      typedef ::std::forward_iterator_tag iterator_category;
      typedef madara::knowledge::KnowledgeRecord value_type;
      typedef int *pointer;
      typedef int &reference;
      typedef int difference_type;

    private:
      madara::utility::LStack <ExpressionTree> stack_;
    };

    class PostOrderIteratorImpl : public ExpressionTreeIteratorImpl
    {
      friend class ExpressionTreeIterator;
      friend class utility::Refcounter<ExpressionTreeIteratorImpl>;
    public:

      PostOrderIteratorImpl (const ExpressionTree &tree, 
                                     bool end_iter = false);

      virtual ~PostOrderIteratorImpl (void);

      virtual ExpressionTree operator* (void);

      virtual const ExpressionTree operator* (void) const;

      virtual void operator++ (void);

      virtual bool operator== (const ExpressionTreeIteratorImpl &rhs)
        const;

      virtual bool operator!= (const ExpressionTreeIteratorImpl &lhs)
        const;

      virtual ExpressionTreeIteratorImpl *clone (void);

      // = Necessary traits
      typedef ::std::forward_iterator_tag iterator_category;
      typedef madara::knowledge::KnowledgeRecord value_type;
      typedef int *pointer;
      typedef int &reference;
      typedef int difference_type;

    private:
      madara::utility::LStack <ExpressionTree> stack_;
    };

    class LevelOrderExpressionTreeIteratorImpl :
      public ExpressionTreeIteratorImpl
    {
      friend class ExpressionTreeIterator;
      friend class utility::Refcounter<ExpressionTreeIteratorImpl>;
    public:

      LevelOrderExpressionTreeIteratorImpl (const ExpressionTree &tree,
                                                 bool end_iter = false);

      virtual ~LevelOrderExpressionTreeIteratorImpl ();

      virtual ExpressionTree operator* (void);

      virtual const ExpressionTree operator* (void) const;

      virtual void operator++ (void);

      virtual bool operator== (const ExpressionTreeIteratorImpl &rhs) const;

      virtual bool operator!= (const ExpressionTreeIteratorImpl &lhs) const;

      virtual ExpressionTreeIteratorImpl *clone (void);

      // = Necessary traits
      typedef ::std::forward_iterator_tag iterator_category;
      typedef madara::knowledge::KnowledgeRecord value_type;
      typedef int *pointer;
      typedef int &reference;
      typedef int difference_type;

    private:
      // @@ Consider zapping this.
      madara::utility::LQueue <ExpressionTree> queue_;
    };
  }
}
#endif /* _MADARA_TREE_ITERATOR_IMPL_H_ */