include/wipal/filter/uniquely_identifiable.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_UNIQUELY_IDENTIFIABLE_HXX_
# define FILTER_UNIQUELY_IDENTIFIABLE_HXX_

# include <wipal/wifi/dissector/dissector.hh>
# include <wipal/wifi/unique_id/unique_id.hh>
# include <wipal/filter/non_noisy_prism.hh>

namespace wpl
{

  namespace filter
  {

    namespace internals
    {

      template <class U, class I, class H, class B1, class B2>
      uniquely_identifiable_iterator<U, I, H, B1, B2>::
      uniquely_identifiable_iterator(const iterable_type&       uif,
                                     bool                       end):
        iterable_ (&uif),
        next_ (end ? uif.end_ : uif.begin_),
        mactime_ (uif.pcap_tstamps_),
        frame_count_ (0),
        uframe_count_ (0)
      {
        if (not end)
          increment();
      }

      template <class U, class I, class H, class B1, class B2>
      bool
      uniquely_identifiable_iterator<U, I, H, B1, B2>::
      equal(const uniquely_identifiable_iterator& rhs) const
      {
        if (not rhs.value())
          return not this->value();
        return next_ == rhs.next_;
      }

      template <class U, class I, class H, class B1, class B2>
      void
      uniquely_identifiable_iterator<U, I, H, B1, B2>::increment()
      {
        wifi::unique_id_factory<U>      factory;
        boost::optional<U>              id;

        while (next_ != iterable_->end_ and not id)
          {
            mactime_.tick<H>(*next_, iterable_->phy_end_);
            id = factory.template build<H>(*next_, *iterable_->mapping_);
            ++next_;
            ++frame_count_;
          }
        if (id)
          {
            this->value() = value_type (mactime_.microseconds(), id.get());
            ++uframe_count_;
          }
        else
          this->value() = boost::none_t ();
      }

      template <class U, class I, class H, class B1, class B2>
      unsigned
      uniquely_identifiable_iterator<U, I, H, B1, B2>::frame_count() const
      {
        return frame_count_;
      }

      template <class U, class I, class H, class B1, class B2>
      unsigned
      uniquely_identifiable_iterator<U, I, H, B1, B2>::
      unique_frame_count() const
      {
        return uframe_count_;
      }

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

    template <class U, class I, class H, class B>
    uniquely_identifiable<U, I, H, B>::
    uniquely_identifiable(const I&              begin,
                          const I&              end,
                          wifi::addr_mapping&   mapping,
                          tool::end::endianness phy_end,
                          bool                  pcap_tstamps):
      begin_ (begin),
      end_ (end),
      mapping_ (&mapping),
      phy_end_ (phy_end),
      pcap_tstamps_ (pcap_tstamps)
    {
    }

    template <class U, class HT, class I, class F>
    void
    for_each_uniquely_identifiable(const I&     first,
                                   const I&     last,
                                   opt::list&   opts,
                                   F&           func)
    {
      typedef tool::end::endianness     endianness;

      const endianness&         end = opts["endianness"].get<endianness>();
      wifi::addr_mapping&       map = opts["mapping"].get<wifi::addr_mapping>();
      const bool                pcapts = not opts["phy_tstamps"].get<bool>();

      if (opts["ignore_noisy_prism"].get<bool>())
        {
          typedef non_noisy_prism<I>                            filter_type;
          typedef typename filter_type::iterator                iterator;
          typedef uniquely_identifiable<U, iterator, HT>        unique_type;

          filter_type   f (first, last);
          unique_type   u (f.begin(), f.end(), map, end, pcapts);

          u.for_each(func);
        }
      else
        {
          typedef uniquely_identifiable<U, I, HT>               unique_type;

          unique_type   u (first, last, map, end, pcapts);

          u.for_each(func);
        }
    }

    // FIXME: Avoid code duplication with the above. :-( :-(
    template <class U, class HT, class I, class F>
    void
    for_each_uniquely_identifiable(const I&             first,
                                   const I&             last,
                                   const opt::list&     opts,
                                   const F&             func)
    {
      typedef tool::end::endianness     endianness;

      const endianness&         end = opts["endianness"].get<endianness>();
      wifi::addr_mapping&       map = opts["mapping"].get<wifi::addr_mapping>();
      const bool                pcapts = not opts["phy_tstamps"].get<bool>();

      if (opts["ignore_noisy_prism"].get<bool>())
        {
          typedef non_noisy_prism<I>                            filter_type;
          typedef typename filter_type::iterator                iterator;
          typedef uniquely_identifiable<U, iterator, HT>        unique_type;

          filter_type   f (first, last);
          unique_type   u (f.begin(), f.end(), map, end, pcapts);

          u.for_each(func);
        }
      else
        {
          typedef uniquely_identifiable<U, I, HT>               unique_type;

          unique_type   u (first, last, map, end, pcapts);

          u.for_each(func);
        }
    }

  } // End of namespace wpl::filter.

} // End of namespace wpl.

#endif // ! FILTER_UNIQUELY_IDENTIFIABLE_HXX_

---