include/wipal/wifi/stats/module.hxx

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

# include <wipal/wifi/stats/module.hh>

namespace wpl
{

  namespace wifi
  {

    namespace stats
    {

      /*-------.
      | module |
      `-------*/

      inline
      void
      module::account_addr(unsigned i, const addr&)
      {
      }

      template <class Frame>
      void
      module::account_beacon(const Frame&               ,
                             const addr* const&         ,
                             const addr* const&         ,
                             const optional_string&     ,
                             const bool&                )
      {
      }

      inline
      void
      module::account_duplicate()
      {
      }

      inline
      void
      module::account_expired()
      {
      }

      template <class Frame>
      void
      module::account_frame(const Frame&                ,
                            const size_t&               ,
                            const type::frame_type&     ,
                            const unsigned&             ,
                            const bool&                 ,
                            const addr* const&          ,
                            const addr* const&          ,
                            const bool&                 )
      {
      }

      inline
      void
      module::account_gap(const unsigned&)
      {
      }

      inline
      void
      module::account_miss()
      {
      }

      inline
      void
      module::account_out_of_order()
      {
      }

      inline
      void
      module::account_seq_anomaly()
      {
      }

      inline
      void
      module::restart()
      {
      }

      /*------------.
      | module_list |
      `------------*/

      template <class H, class T>
      module_list<H, T>::module_list(): H (this), T (this)
      {
      }

      template <class H, class T>
      template <class ML>
      module_list<H, T>::module_list(const ML* other_modules):
        H (other_modules),
        T (other_modules)
      {
      }

# define WP_module_list_delegate(FunCall)       \
      T::FunCall;                               \
      H::FunCall

      template <class H, class T>
      void
      module_list<H, T>::account_addr(unsigned i, const addr& a)
      {
        WP_module_list_delegate(account_addr(i, a));
      }

      template <class H, class T>
      template <class Frame>
      void
      module_list<H, T>::
      account_beacon(const Frame&               frame,
                     const addr* const&         ap,
                     const addr* const&         bss,
                     const optional_string&     ssid,
                     const bool&                ibss)
      {
        WP_module_list_delegate(account_beacon(frame, ap, bss, ssid, ibss));
      }

      template <class H, class T>
      void
      module_list<H, T>::account_duplicate()
      {
        WP_module_list_delegate(account_duplicate());
      }

      template <class H, class T>
      void
      module_list<H, T>::account_expired()
      {
        WP_module_list_delegate(account_expired());
      }

      template <class H, class T>
      template <class Frame>
      void
      module_list<H, T>::
      account_frame(const Frame&                frame,
                    const size_t&               len80211,
                    const type::frame_type&     type,
                    const unsigned&             subtype,
                    const bool&                 retx,
                    const addr* const&          receiver,
                    const addr* const&          transmitter,
                    const bool&                 from_ap)
      {
        WP_module_list_delegate(account_frame(frame, len80211, type, subtype,
                                              retx, receiver, transmitter,
                                              from_ap));
      }

      template <class H, class T>
      void
      module_list<H, T>::account_gap(const unsigned& gaplen)
      {
        WP_module_list_delegate(account_gap(gaplen));
      }

      template <class H, class T>
      void
      module_list<H, T>::account_miss()
      {
        WP_module_list_delegate(account_miss());
      }

      template <class H, class T>
      void
      module_list<H, T>::account_out_of_order()
      {
        WP_module_list_delegate(account_out_of_order());
      }

      template <class H, class T>
      void
      module_list<H, T>::account_seq_anomaly()
      {
        WP_module_list_delegate(account_seq_anomaly());
      }

      template <class H, class T>
      void
      module_list<H, T>::restart()
      {
        WP_module_list_delegate(restart());
      }

# undef WP_module_list_delegate

      template <class H, class T>
      std::ostream&
      module_list<H, T>::print(std::ostream& os) const
      {
        return T::print(H::print(os) << '\n');
      }

      template <class H, class Tail>
      template <class T>
      T&
      module_list<H, Tail>::get()
      {
        return *static_cast<T*> (this);
      }

      template <class H, class Tail>
      template <class T>
      const T&
      module_list<H, Tail>::get() const
      {
        return *static_cast<const T*> (this);
      }

      template <class H, class T>
      std::ostream&
      operator << (std::ostream& os, const module_list<H, T>& ml)
      {
        return ml.print(os);
      }

    } // End of namespace wpl::wifi::stats.

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

#endif // ! WIFI_STATS_MODULE_HXX_

---