include/wipal/filter/deprecated/simple_merge.hxx

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

# include <iostream>

# include "simple_merge.hh"

# include <wipal/wifi/frame/filter/merge.hh>

namespace wifi
{
  namespace frame
  {
    namespace filter
    {

      namespace internals
      {

        template <class HT, class I1, class I2, class B1, class B2>
        simple_merge_iterator<HT, I1, I2, B1, B2>::
	simple_merge_iterator(const iterable_type& i, bool end):
          iterable_ (&i),
          next1_ (end ? i.last1_ : i.first1_),
          next2_ (end ? i.last2_ : i.first2_),
          current_ (first_packet())
# ifdef WP_ENABLE_INFO
        , lhs_total_ (0),
          rhs_total_ (0),
          shared_ (0),
          total_ (0),
          sync_error_ (0)
# endif // WP_ENABLE_INFO
        {
        }


# ifdef WP_ENABLE_INFO
#  define WP_increment(X) ++(X)
# else // ! WP_ENABLE_INFO
#  define WP_increment(X) (void) 0
# endif // WP_ENABLE_INFO

        template <class HT, class I1, class I2, class B1, class B2>
        bool
        simple_merge_iterator<HT, I1, I2, B1, B2>::
	equal(const simple_merge_iterator& rhs) const
        {
          return next1_ == rhs.next1_ and next2_ == rhs.next2_;
        }

        template <class HT, class I1, class I2, class B1, class B2>
        void
        simple_merge_iterator<HT, I1, I2, B1, B2>::increment()
        {
          typedef internals::equal<HT>  equal;

          assert(current_ == 0 or current_ == 1);

          if (next1_ == iterable_->last1_)
            {
              ++next2_;
              WP_increment(rhs_total_);
            }
          else if (next2_ == iterable_->last2_)
            {
              ++next1_;
              WP_increment(lhs_total_);
            }
          else if (equal (*next1_, iterable_->phy_end_) == *next2_)
            {
# ifdef WP_ENABLE_INFO
              {
                const tool::microseconds& t1 = next1_->microseconds();
                const tool::microseconds& t2 = next2_->microseconds();

                if (t1 > t2)
                  sync_error_ += tool::microseconds (t1 - t2).get_ui();
                else
                  sync_error_ += tool::microseconds (t2 - t1).get_ui();
              }
              ++lhs_total_;
              ++rhs_total_;
              ++shared_;
# endif // WP_ENABLE_INFO
              ++next1_;
              ++next2_;
            }
          else
            {
              if (current_)
                {
                  ++next2_;
                  WP_increment(rhs_total_);
                }
              else
                {
                  ++next1_;
                  WP_increment(lhs_total_);
                }
            }
          WP_increment(total_);

          current_ = first_packet();

# ifdef WP_ENABLE_INFO
          if (current_ == -1)
            std::cerr << "INFO: " << shared_ << " frames shared by"
                                                " both traces.\n"
                      << "INFO: Trace 1 has " << lhs_total_ << " frames ("
                      << (shared_ * 100.f / lhs_total_) << "% shared).\n"
                      << "INFO: Trace 2 has " << rhs_total_ << " frames ("
                      << (shared_ * 100.f / rhs_total_) << "% shared).\n"
                      << "INFO: Output has " << total_ << " frames ("
                      << (shared_ * 100.f / total_) << "% shared).\n"
                      << "INFO: Mean sync. error is "
                      << (sync_error_ / shared_) << " microseconds."
                      << std::endl;
# endif // WP_ENABLE_INFO
        }

# undef WP_increment

        template <class HT, class I1, class I2, class B1, class B2>
        const typename simple_merge_iterator<HT, I1, I2, B1, B2>::value_type&
        simple_merge_iterator<HT, I1, I2, B1, B2>::get() const
        {
          assert(current_ == 0 or current_ == 1);

          if (current_)
            return *next2_;
          else
            return *next1_;
        }

        template <class HT, class I1, class I2, class B1, class B2>
        typename simple_merge_iterator<HT, I1, I2, B1, B2>::value_type&
        simple_merge_iterator<HT, I1, I2, B1, B2>::get()
        {
          assert(current_ == 0 or current_ == 1);

          if (current_)
            return next2_.get();
          else
            return next1_.get();
        }

        template <class HT, class I1, class I2, class B1, class B2>
        const typename simple_merge_iterator<HT, I1, I2, B1, B2>::value_type*
        simple_merge_iterator<HT, I1, I2, B1, B2>::get_ptr() const
        {
          assert(current_ == 0 or current_ == 1);

          if (current_)
            return next2_.get_ptr();
          else
            return next1_.get_ptr();
        }

        template <class HT, class I1, class I2, class B1, class B2>
        typename simple_merge_iterator<HT, I1, I2, B1, B2>::value_type*
        simple_merge_iterator<HT, I1, I2, B1, B2>::get_ptr()
        {
          assert(current_ == 0 or current_ == 1);

          if (current_)
            return next2_.get_ptr();
          else
            return next1_.get_ptr();
        }

        template <class HT, class I1, class I2, class B1, class B2>
        int
        simple_merge_iterator<HT, I1, I2, B1, B2>::first_packet() const
        {
          const bool first_at_end       = next1_ == iterable_->last1_;
          const bool second_at_end      = next2_ == iterable_->last2_;

          if (first_at_end)
            return second_at_end ? -1 : 1;
          if (second_at_end)
            return 0;

          return next1_->microseconds() < next2_->microseconds() ? 0 : 1;
        }

      } // End of namespace internals.

      template <class HeaderType,
                class InputIterator1,
                class InputIterator2,
                class Bottom>
      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):
        phy_end_ (phy_end),
        first1_ (first1),
        last1_ (last1),
        first2_ (first2),
        last2_ (last2)
      {
      }

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

  } // End of namespace wifi::frame.

} // End of namespace wifi.

#endif // ! WIFI_FRAME_FILTER_SIMPLE_MERGE_HXX_

---