include/wipal/filter/windowed_merge.hh

/*
 * 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 FILTER_WINDOWED_MERGE_HH_
# define FILTER_WINDOWED_MERGE_HH_

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

namespace wpl
{

  /*---------------------.
  | Forward declarations |
  `---------------------*/
  namespace filter
  {
    namespace internals
    {
      template <class, class, class, class, class>
      struct windowed_merge_iterator;
    }

    template <class, class, class, class>
    struct windowed_merge;
  }


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

  namespace tool
  {

    template <class HT, class I1, class I2, class B1, class B2>
    struct types< wpl::filter::internals::
                  windowed_merge_iterator<HT, I1, I2, B1, B2> >
    {
      typedef typename I1::value_type                           value_type;
      typedef wpl::filter::windowed_merge<HT, I1, I2, B1>       iterable_type;
    };

    template <class HT, class I1, class I2, class B>
    struct types< wpl::filter::windowed_merge<HT, I1, I2, B> >
    {
      typedef wpl::filter::internals::
      windowed_merge_iterator<HT, I1, I2, B, bottom>
      iterator;
    };

  } // End of namespace wpl::tool.


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

  namespace filter
  {

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


        typedef WP_GET_EXACT(Bottom, windowed_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;

        windowed_merge_iterator(const iterable_type& i, bool end);


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

      private:
        typedef std::deque<typename I1::value_type>     window1_type;
        typedef std::deque<typename I2::value_type>     window2_type;

        int                     first_packet() const;

        void                    update_current();

        template <class WindowType, class I>
          static
          unsigned
          fill(WindowType&      w,
               I&               i,
               const I&         last,
               size_t           n);

        typedef typename window1_type::iterator         win1_iterator;
        typedef typename window2_type::iterator         win2_iterator;
        typedef std::pair<win1_iterator, win2_iterator> match_type;
        typedef boost::optional<match_type>             optional_match;

        optional_match  match();

        enum
        {
          window_size =

#ifdef WP_WMERGE_WINDOW_SIZE
          WP_WMERGE_WINDOW_SIZE
#else // ! WP_WMERGE_WINDOW_SIZE
          3
#endif // WP_WMERGE_WINDOW_SIZE
        };

        const iterable_type*    iterable_;

        I1                      next1_;
        I2                      next2_;

        window1_type            win1_;
        window2_type            win2_;

        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 windowed_merge:
      WP_INHERIT(public tool::iterable, windowed_merge<HeaderType,
                                                       InputIterator1,
                                                       InputIterator2,
                                                       Bottom>)
    {
      windowed_merge(const InputIterator1&              first1,
                     const InputIterator1&              last1,
                     const InputIterator2&              first2,
                     const InputIterator2&              last2,
                     const unsigned                     precision,
                     const tool::end::endianness        phy_end,
                     const bool                         pcap_tstamps);

    private:
      unsigned                  precision_;
      tool::end::endianness     phy_end_;
      bool                      pcap_tstamps_;

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

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

  } // End of namespace wpl::filter.

} // End of namespace wpl.

# include "windowed_merge.hxx"

#endif // ! FILTER_WINDOWED_MERGE_HH_

---