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

# include <wipal/tool/endianness.hh>
# include <wipal/tool/microseconds_stamp.hh>
# include <wipal/tool/valued_iterator.hh>
# include <wipal/phy/timetracker.hh>
# include <wipal/tool/iterable.hh>
# include <wipal/wifi/addr_mapping.hh>

# include "uniquely_identifiable_fwd.hh"

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

namespace wpl
{

  namespace tool
  {

    template <class U, class I, class H, class B1, class B2>
    struct types< wpl::filter::internals::
                    uniquely_identifiable_iterator<U, I, H, B1, B2> >
    {
      typedef
        wpl::filter::uniquely_identifiable<U, I, H, B1> iterable_type;
      typedef tool::microseconds_stamp<U>               value_type;
    };

    template <class U, class I, class H, class B>
    struct types< wpl::filter::uniquely_identifiable<U, I, H, B> >
    {
      typedef wpl::filter::internals::
        uniquely_identifiable_iterator<U, I, H, B, bottom>
      iterator;
    };

  } // End of namespace tool.

} // End of namespace wpl.

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

namespace wpl
{

  namespace filter
  {

    namespace internals
    {

      template <class U, class I, class H, class B, class Bottom>
      struct uniquely_identifiable_iterator:
        WP_INHERIT(public tool::valued_iterator,
                   uniquely_identifiable_iterator<U, I, H, B, Bottom>)
      {


        typedef WP_GET_EXACT(Bottom,
                             uniquely_identifiable_iterator<U, I, H,
                             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;

        uniquely_identifiable_iterator(const iterable_type& uif, bool end);


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

        unsigned        frame_count() const;

        unsigned        unique_frame_count() const;

      private:
        const iterable_type*    iterable_;
        I                       next_;
        phy::timetracker<>      mactime_;
        unsigned                frame_count_;
        unsigned                uframe_count_;
      };

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


    template <class UniqueId,
              class InputIterator,
              class HeaderType,
              class Bottom = tool::bottom>
    struct uniquely_identifiable:
      WP_INHERIT(public tool::iterable,
                 uniquely_identifiable<UniqueId, InputIterator, HeaderType,
                 Bottom>)
    {
      uniquely_identifiable(const InputIterator&        begin,
                            const InputIterator&        end,
                            wifi::addr_mapping&         map,
                            tool::end::endianness       phy_end,
                            bool                        pcap_tstamps);

    private:
      InputIterator             begin_;
      InputIterator             end_;
      wifi::addr_mapping*       mapping_;
      tool::end::endianness     phy_end_;
      bool                      pcap_tstamps_;

      friend
        class internals::uniquely_identifiable_iterator<UniqueId,
        InputIterator,
        HeaderType,
        Bottom,
        tool::bottom>;
    };

    template <class UniqueId, class HeaderType, class I, class F>
    void
    for_each_uniquely_identifiable(const I&     first,
                                   const I&     last,
                                   opt::list&   options,
                                   F&           func);

    template <class UniqueId, class HeaderType, class I, class F>
    void
    for_each_uniquely_identifiable(const I&     first,
                                   const I&     last,
                                   opt::list&   options,
                                   const F&     func);

  } // End of namespace wpl::filter.

} // End of namespace wpl.

# include "uniquely_identifiable.hxx"

#endif // ! FILTER_UNIQUELY_IDENTIFIABLE_HH_

---