include/wipal/filter/deprecated/simple_merge.hh

/*
 * WiPal - A library and a set of tools to manipulate wireless traces.
 * Copyright (C) 2007, 2008  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 WIFI_FRAME_FILTER_SIMPLE_MERGE_HH_
# define WIFI_FRAME_FILTER_SIMPLE_MERGE_HH_

# include <wipal/tool/iterator.hh>
# include <wipal/tool/iterable.hh>
# include <wipal/wifi/addr_mapping.hh>

/*---------------------.
| Forward declarations |
`---------------------*/
namespace wifi
{
  namespace frame
  {
    namespace filter
    {

      namespace internals
      {
        template <class, class, class, class, class>
        struct simple_merge_iterator;
      }

      template <class, class, class, class>
      struct simple_merge;

    }
  }
}


/*--------------.
| Virtual types |
`--------------*/

namespace tool
{

  template <class HT, class I1, class I2, class B1, class B2>
  struct types< wifi::frame::filter::internals::
                simple_merge_iterator<HT, I1, I2, B1, B2> >
  {
    typedef typename I1::value_type                             value_type;
    typedef wifi::frame::filter::simple_merge<HT, I1, I2, B1>   iterable_type;
  };

  template <class HT, class I1, class I2, class B>
  struct types< wifi::frame::filter::simple_merge<HT, I1, I2, B> >
  {
    typedef wifi::frame::filter::internals::
      simple_merge_iterator<HT, I1, I2, B, bottom>
      iterator;
  };

} // End of namespace tool.


/*-------------.
| Declarations |
`-------------*/

namespace wifi
{
  namespace frame
  {
    namespace filter
    {

      namespace internals
      {
        template <class HT,
                  class I1, class I2,
                  class B, class Bottom = tool::bottom>
        struct simple_merge_iterator:
          WP_INHERIT(public tool::iterator,
                     simple_merge_iterator<HT, I1, I2, B, Bottom>)
        {


          typedef WP_GET_EXACT(Bottom, simple_merge_iterator<HT, I1, I2,
                                                             B, Bottom>)
                                                        exact_type;
          typedef tool::iterator<exact_type>            super_type;
          typedef WP_TYPE(value_type, exact_type)       value_type;
          typedef WP_TYPE(iterable_type, exact_type)    iterable_type;

          simple_merge_iterator(const iterable_type& i, bool end);


          bool                  equal(const simple_merge_iterator& rhs) const;
          void                  increment();

          const value_type&     get() const;
          value_type&           get();

          const value_type*     get_ptr() const;
          value_type*           get_ptr();

        private:
          int                   first_packet() const;

          const iterable_type*  iterable_;

          I1                    next1_;
          I2                    next2_;
          int                   current_;
# ifdef WP_ENABLE_INFO
          unsigned              lhs_total_;
          unsigned              rhs_total_;
          unsigned              shared_;
          unsigned              total_;
          double                sync_error_;
# endif // WP_ENABLE_INFO
        };

      } // End of namespace internals.


      template <class HeaderType,
                class InputIterator1,
                class InputIterator2,
                class Bottom = tool::bottom>
      struct simple_merge:
        WP_INHERIT(public tool::iterable, simple_merge<HeaderType,
                                                       InputIterator1,
                                                       InputIterator2,
                                                       Bottom>)
      {
        simple_merge(const InputIterator1& first1, const InputIterator1& last1,
                     const InputIterator2& first2, const InputIterator2& last2,
                     tool::endian::endianness phy_end);

      private:
        tool::endian::endianness        phy_end_;

        InputIterator1                  first1_;
        InputIterator1                  last1_;
        InputIterator2                  first2_;
        InputIterator2                  last2_;

        friend
          class internals::simple_merge_iterator<HeaderType,
                                                 InputIterator1,
                                                 InputIterator2,
                                                 Bottom,
                                                 tool::bottom>;
      };

    } // End of namespace wifi::frame::filter.

  } // End of namespace wifi::frame.

} // End of namespace wifi.

# include "simple_merge.hxx"

#endif // ! WIFI_FRAME_FILTER_SIMPLE_MERGE_HH_

---