include/wipal/filter/merge.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 FILTER_MERGE_HXX_
# define FILTER_MERGE_HXX_

extern "C"
{
# include <time.h>
}

# include "merge.hh"

# include <wipal/filter/time_adjuster.hh>

namespace wpl
{

  namespace filter
  {

    namespace internals
    {

      template <class HeaderType, class S1>
      equal<HeaderType, S1>::
      equal(const pkt::packet<S1>&              lhs,
            const unsigned&                     precision,
            const tool::end::endianness&        phy_end,
            const bool&                         force_pcap):
        lhs_ (lhs),
        precision_ (precision),
        phy_end_ (phy_end),
        force_pcap_ (force_pcap)
      {
      }

      template <class HeaderType, class S1>
      template <class S2>
      bool
      equal<HeaderType, S1>::
      operator == (const pkt::packet<S2>& rhs) const
      {
        if (force_pcap_)
          return (tool::eq_timeval(lhs_.meta().ts, rhs.meta().ts, precision_)
                  and
                  HeaderType::eq_80211(lhs_, rhs, phy_end_));
        else
          return HeaderType::eq_time_and_80211(lhs_, rhs,
                                               precision_, phy_end_);
      }

      template <class HT, class S1>
      equal<HT, S1>
      make_equal(const pkt::packet<S1>&         lhs,
                 const unsigned&                precision,
                 const tool::end::endianness&   phy_end,
                 const bool&                    force_pcap)
      {
        return equal<HT, S1> (lhs, precision, phy_end, force_pcap);
      }

      template <class HT, class S1, class S2>
      bool
      operator == (const pkt::packet<S2>&       lhs,
                   const equal<HT, S1>&         rhs)
      {
        return rhs == lhs;
      }

      template <class HT, template <class, class, class, class> class Merger,
                class I, class F>
      struct merge_wrapper
      {
        merge_wrapper(const I&          first2,
                      const I&          last2,
                      opt::list&        options,
                      F&                func):
          first2_ (first2),
          last2_ (last2),
          options_ (options),
          func_ (func)
        {
        }

        template <class TimeAdjuster>
        void
        operator () (const TimeAdjuster& a)
        {
          typedef tool::end::endianness endianness;

          const unsigned&   prec = options_["precision"].get<unsigned>();
          const endianness& end = options_["endianness"].get<endianness>();
          const bool        pcapts = not options_["phy_tstamps"].get<bool>();

          if (options_["ignore_noisy_prism"].get<bool>())
            {
              typedef non_noisy_prism<I>                        nnp;
              typedef typename nnp::const_iterator              nnp_iterator;
              typedef timetracker<nnp_iterator, HT>             tt;
              typedef typename tt::const_iterator               tt_iterator;
              typedef typename TimeAdjuster::const_iterator     ta_iterator;
              typedef Merger<HT, ta_iterator, tt_iterator, tool::bottom> merger;

              nnp       n (first2_, last2_);
              tt        s (n.begin(), n.end(), end, pcapts);
              merger    m (a.begin(), a.end(), s.begin(), s.end(),
                           prec, end, pcapts);

              func_(m);
            }
          else
            {
              typedef timetracker<I, HT>                        tt;
              typedef typename tt::const_iterator               tt_iterator;
              typedef typename TimeAdjuster::const_iterator     ta_iterator;
              typedef Merger<HT, ta_iterator, tt_iterator, tool::bottom> merger;

              tt        s (first2_, last2_, end, pcapts);
              merger    m (a.begin(), a.end(), s.begin(), s.end(),
                           prec, end, pcapts);

              func_(m);
            }
        }

      private:
        const I&        first2_;
        const I&        last2_;
        opt::list&      options_;
        F&              func_;
      };

    } // End of namespace wpl::filter::internals.

    template <class U, class HT,
              template <class, class, class> class Int,
              template <class, class, class, class> class Merger,
              class I1, class I2, class F>
    void
    provide_merge(const I1& first1, const I1&   last1,
                  const I2& first2, const I2&   last2,
                  opt::list&    options,
                  F&            func)
    {
      internals::merge_wrapper<HT, Merger, I2, F> wrap (first2, last2,
                                                        options, func);

      provide_time_adjuster<U, HT, Int>(first1, last1,
                                        first2, last2, options, wrap);
    }

  } // End of namespace wpl::filter.

} // End of namespace wpl.

#endif // ! FILTER_MERGE_HXX_

---