include/wipal/tool/list_of_iterables.hxx

/*
 * WiPal - A library and a set of tools to manipulate wireless traces.
 * Copyright (C) 2007, 2008, 2009  Universite Pierre et Marie Curie - Paris 6
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
 * MA  02110-1301  USA
 *
 * Author: Thomas Claveirole <thomas.claveirole@lip6.fr>
 */
#ifndef TOOL_LIST_OF_ITERABLES_HXX_
# define TOOL_LIST_OF_ITERABLES_HXX_

# include <boost/foreach.hpp>

# include "list_of_iterables.hh"

namespace wpl
{

  namespace tool
  {

    template <class T, class B1, class B2>
    list_of_iterables_iterator<T, B1, B2>::
    list_of_iterables_iterator(const iterable_type& list, bool end):
      super_type ()
    {
      if (not end)
        {
          BOOST_FOREACH(const T& i, list.list_)
            {
              const inner_iterator_type b = i.begin();
              const inner_iterator_type e = i.end();

              if (b != e)
                {
                  begins_.push(b);
                  ends_.push(e);
                }
            }
        }
    }

    template <class T, class B1, class B2>
    bool
    list_of_iterables_iterator<T, B1, B2>::equal(const exact_type& rhs) const
    {
      const bool r = begins_ == rhs.begins_;

      assert(not r or ends_ == rhs.ends_);
      return r;
    }

    template <class T, class B1, class B2>
    void
    list_of_iterables_iterator<T, B1, B2>::increment()
    {
      // Preconditions.
      assert(not begins_.empty() and not ends_.empty());
      assert(begins_.front() != ends_.front());

      if (++begins_.front() == ends_.front())
        {
          begins_.pop();
          ends_.pop();
        }

      // Postconditions.
      assert(begins_.empty() or (not ends_.empty() and
                                 begins_.front() != ends_.front()));
    }

    template <class T, class B1, class B2>
    const typename list_of_iterables_iterator<T, B1, B2>::value_type&
    list_of_iterables_iterator<T, B1, B2>::get() const
    {
      assert(not begins_.empty());
      assert(begins_.front() != ends_.front());

      return *begins_.front();
    }

    template <class T, class B1, class B2>
    const typename list_of_iterables_iterator<T, B1, B2>::value_type*
    list_of_iterables_iterator<T, B1, B2>::get_ptr() const
    {
      assert(not begins_.empty());
      assert(begins_.front() != ends_.front());

      return &*begins_.front();
    }

    template <class T, class B>
    list_of_iterables<T, B>::list_of_iterables(): super_type ()
    {
    }

    template <class T, class B>
    template <class L>
    list_of_iterables<T, B>::list_of_iterables(const L& list): super_type ()
    {
      BOOST_FOREACH(const T& i, list)
        list_.push_back(i);
    }

    template <class T, class B>
    bool
    list_of_iterables<T, B>::empty() const
    {
      return list_.empty() or this->begin() == this->end();
    }

    template <class T, class B>
    size_t
    list_of_iterables<T, B>::size() const
    {
      return list_.size();
    }

    template <class T, class B>
    typename list_of_iterables<T, B>::exact_type&
    list_of_iterables<T, B>::push_back(const T& i)
    {
      list_.push_back(i);

      return this->exact();
    }

    template <class T, class B>
    const T&
    list_of_iterables<T, B>::get(unsigned i) const
    {
      assert(i < list_.size());

      return list_[i];
    }

    template <class T, class B>
    T&
    list_of_iterables<T, B>::get(unsigned i)
    {
      assert(i < list_.size());

      return list_[i];
    }

  } // End of namespace wpl::tool.

} // End of namespace wpl.

#endif // ! TOOL_ITERABLE_HXX_

---