include/wipal/filter/non_noisy_prism.hxx

/*
 * WiPal - A library and a set of tools to manipulate wireless traces.
 * Copyright (C) 2007, 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_NON_NOISY_PRISM_HXX_
# define FILTER_NON_NOISY_PRISM_HXX_

# include "non_noisy_prism.hh"

# include <wipal/phy/prism_header.hh>

namespace wpl
{

  namespace filter
  {

    namespace internals
    {

      template <class I, class B, class Bottom>
      non_noisy_prism_iterator<I, B, Bottom>::
      non_noisy_prism_iterator(const iterable_type& i, bool end):
        iterable_ (&i),
        current_  (end ? i.end_ : i.begin_)
      {
        skip_noisy();
      }

      template <class I, class B, class Bottom>
      bool
      non_noisy_prism_iterator<I, B, Bottom>::
      equal(const non_noisy_prism_iterator& rhs) const
      {
        return current_ == rhs.current_;
      }


      template <class I, class B, class Bottom>
      void
      non_noisy_prism_iterator<I, B, Bottom>::increment()
      {
        ++current_;
        skip_noisy();
      }

      template <class I, class B, class Bottom>
      const typename non_noisy_prism_iterator<I, B, Bottom>::value_type&
      non_noisy_prism_iterator<I, B, Bottom>::get() const
      {
        return current_.get();
      }

      template <class I, class B, class Bottom>
      typename non_noisy_prism_iterator<I, B, Bottom>::value_type&
      non_noisy_prism_iterator<I, B, Bottom>::get()
      {
        return current_.get();
      }

      template <class I, class B, class Bottom>
      const typename non_noisy_prism_iterator<I, B, Bottom>::value_type*
      non_noisy_prism_iterator<I, B, Bottom>::get_ptr() const
      {
        return current_.get_ptr();
      }

      template <class I, class B, class Bottom>
      typename non_noisy_prism_iterator<I, B, Bottom>::value_type*
      non_noisy_prism_iterator<I, B, Bottom>::get_ptr()
      {
        return current_.get_ptr();
      }

      template <class I, class B, class Bottom>
      bool
      non_noisy_prism_iterator<I, B, Bottom>::noisy(const void* frame,
                                                    size_t              caplen)
      {
        /*
         * In case we cannot decide whether the frame is noisy or
         * not, return true.  This is a conservative approach, as we
         * want to be sure no noisy frame go through.  Anyway, such
         * a frame is unlikely to occur, and would not be very
         * useful.
         */
        if (caplen < sizeof (prism::header))
          return true;

        const prism::header* const h =
          static_cast<const prism::header*> (frame);

        return h->noise.get(false);
      }

      template <class I, class B, class Bottom>
      void
      non_noisy_prism_iterator<I, B, Bottom>::skip_noisy()
      {
        while (current_ != iterable_->end_ and
               noisy(current_->bytes(), current_->meta().caplen))
          ++current_;
      }

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


    template <class InputIterator, class Bottom>
    non_noisy_prism<InputIterator, Bottom>::
    non_noisy_prism(const InputIterator& begin, const InputIterator& end):
      begin_ (begin),
      end_ (end)
    {
    }

    template <class InputIterator, class Bottom>
    template <class Iterable>
    non_noisy_prism<InputIterator, Bottom>::
    non_noisy_prism(const Iterable& i):
      begin_ (i.begin()),
      end_ (i.end())
    {
    }

  } // End of namespace wpl::filter.

} // End of namespace wpl.

#endif // ! FILTER_NON_NOISY_PRISM_HXX_

---