include/wipal/filter/linear_regression_synchronizer.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_SYNCHRONIZER_HH_
# define FILTER_SYNCHRONIZER_HH_

# include <utility>

# include <wipal/tool/valued_iterator.hh>
# include <wipal/tool/iterable.hh>
# include <wipal/wifi/addr_mapping.hh>

# include "linear_regression_synchronizer_fwd.hh"

namespace wpl
{

  // Virt. types.
  namespace tool
  {

    template <class I, class B1, class B2>
    struct types< wpl::filter::internals::lr_sync_iterator<I, B1, B2> >
    {
      typedef wpl::filter::
      synchronized_frame<typename I::value_type::value_type, mpf_class>
      value_type;
    };

    template <class I, class B>
    struct types< wpl::filter::linear_regression_synchronizer<I, B> >
    {
      typedef
      wpl::filter::internals::lr_sync_iterator<I, B, bottom>
      iterator;
    };

  } // End of namespace tool.


  // Defs.
  namespace filter
  {

    template <class OriginalFrameType, class ImplType>
    struct synchronized_frame: public OriginalFrameType
    {
      typedef ImplType                                  impl_type;
      typedef typename std::pair<impl_type, impl_type>  coefs_type;

      synchronized_frame(const OriginalFrameType&, const coefs_type&);

      coefs_type        coefs;
    };

    namespace internals
    {

      template <class I, class B, class Bottom = tool::bottom>
      struct lr_sync_iterator: WP_INHERIT(public tool::valued_iterator,
                                          lr_sync_iterator<I, B, Bottom>)
      {

        typedef WP_GET_EXACT(Bottom, lr_sync_iterator<I, B, Bottom>)
                                                        exact_type;
        typedef tool::valued_iterator<exact_type>       super_type;
        typedef WP_TYPE(value_type, exact_type)         value_type;

        typedef linear_regression_synchronizer<I, B>    iterable_type;

        lr_sync_iterator(const iterable_type& iterable, bool end);


        bool                    equal(const exact_type&) const;
        void                    increment();

      private:
        bool                    advance();
        bool                    update_value();

        const iterable_type*    iterable_;
        I                       win_;
        unsigned                wpos_;
      };

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

    template <class InputIterator, class Bottom = tool::bottom>
    struct linear_regression_synchronizer:
      WP_INHERIT(public tool::iterable,
                 linear_regression_synchronizer<InputIterator, Bottom>)
    {
      linear_regression_synchronizer(const InputIterator&       first,
                                     const InputIterator&       last,
                                     const unsigned             precision);

    private:
      InputIterator     first_;
      InputIterator     last_;
      unsigned          precision_;

      friend class
        internals::lr_sync_iterator<InputIterator, Bottom, tool::bottom>;
    };

    template <class U, class HT, template <class, class, class> class Int,
              class I1, class I2, class F>
    void
    provide_lr_synchronizer(const I1& first1, const I1& last1,
                            const I2& first2, const I2& last2,
                            opt::list&  options,
                            F&          func);

  } // End of namespace wpl::filter.

} // End of namespace wpl.

# include "linear_regression_synchronizer.hxx"

#endif // ! FILTER_SYNCHRONIZER_HH_

---