include/wipal/filter/deprecated/old_intersector.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_OLD_INTERSECTOR_HH_
# define WIFI_FRAME_FILTER_OLD_INTERSECTOR_HH_

# include <utility>

# include <wipal/tool/iterable.hh>
# include <wipal/tool/hash.hh>
# include <wipal/tool/valued_iterator.hh>
# include <wipal/tool/microseconds.hh>

# include "old_intersector_fwd.hh"

// Virtual types.
namespace tool
{

  template <class I1, class I2, class B1, class B2>
  struct types< wifi::frame::filter::internals::
                old_intersector_iterator<I1, I2, B1, B2> >
  {
    typedef     std::pair<typename I1::value_type, typename I2::value_type>
                value_type;

    typedef     wifi::frame::filter::old_intersector<I1, I2, B1>
                iterable_type;
  };

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

} // End of namespace tool.

// Declarations.
namespace wifi
{
  namespace frame
  {
    namespace filter
    {

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


          typedef WP_GET_EXACT(Bottom,
                               old_intersector_iterator<I1, I2, B, Bottom>)
                                                        exact_type;
          typedef tool::valued_iterator<exact_type>     super_type;
          typedef WP_TYPE(value_type, exact_type)       value_type;
          typedef WP_TYPE(iterable_type, exact_type)    iterable_type;

          old_intersector_iterator(const iterable_type& i, bool end);


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

        private:

# ifdef WP_DONT_USE_HASH
          enum
          {
            arrivals_max_size = 1 << 20
          };

          typedef std::set<typename I1::value_type> arrivals1_type;
          typedef std::set<typename I2::value_type> arrivals2_type;
# else
          enum
          {
            arrivals_max_size = 1 << 20,

            hash_bucket_count = arrivals_max_size * 4
          };

          typedef tool::hash_set<typename I1::value_type> arrivals1_type;
          typedef tool::hash_set<typename I2::value_type> arrivals2_type;
# endif

          template <bool SwapResult, class ArrType, class RHSArrType>
          bool
          check(I1&             frm,
                ArrType&        frm_arrivals,
                RHSArrType&     rhs_arrivals);

          template <class ArrType>
          void
          cleanup_arrivals(const typename ArrType::iterator&    frame,
                           ArrType&                             arrivals);


          const iterable_type*  iterable_;

          I1                    next1_;
          I2                    next2_;

          arrivals1_type        arrivals1_;
          arrivals2_type        arrivals2_;
          tool::microseconds    last_arrival_[2];
        };

      } // End of namespace internals.


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

      private:
        InputIterator1  first1_;
        InputIterator1  last1_;
        InputIterator2  first2_;
        InputIterator2  last2_;

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

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

  } // End of namespace wifi::frame.

} // End of namespace wifi.

# include "old_intersector.hxx"

#endif // ! WIFI_FRAME_FILTER_OLD_INTERSECTOR_HH_

---