include/wipal/wifi/stats/growth.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_GROWTH_HXX_
# define WIFI_STATS_GROWTH_HXX_

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

namespace wpl
{

  namespace wifi
  {

    namespace stats
    {

      /*-------.
      | growth |
      `-------*/

      template <class T, unsigned EL>
      void
      growth<T, EL>::restart()
      {
        tracker_.restart();
        elements_.clear();
        current_elements_.clear();
      }

      template <class T, unsigned EL>
      void
      growth<T, EL>::update(const tool::microseconds& timestamp)
      {
        if (tracker_.update(timestamp))
          current_elements_.clear();
      }

      template <class T, unsigned EL>
      void
      growth<T, EL>::update(const T& elt)
      {
        epoch_data&     d = tracker_.current();

        if (current_elements_.insert(elt).second)
          ++d.current_count;

        if (elements_.insert(elt).second)
          ++d.total_count;
      }

      template <class T, unsigned EL>
      std::ostream&
      growth<T, EL>::print(std::ostream& o) const
      {
        unsigned        total = 0;

        BOOST_FOREACH(const epoch_data& e, tracker_.epochs())
          {
            total += e.total_count;
            o << '\t' << e.total_count
              << '\t' << total
              << '\t' << e.current_count << '\n';
          }
        return o << std::flush;
      }

      /*-----------.
      | epoch_data |
      `-----------*/

      template <class T, unsigned EL>
      growth<T, EL>::epoch_data::epoch_data(): total_count (0),
                                               current_count (0)
      {
      }

      /*------------.
      | addr_growth |
      `------------*/

      template <unsigned E, bool Tx>
      addr_growth<E, Tx>::addr_growth(const void*): ignore_ (true)
      {
      }

      template <unsigned E, bool Tx>
      void
      addr_growth<E, Tx>::account_addr(unsigned i, const addr& a)
      {
        if (ignore_ or (Tx and i != 2))
          return;

        growth_.update(a);
      }

      template <unsigned E, bool Tx>
      template <class Frame>
      void
      addr_growth<E, Tx>::account_frame(const Frame&            frame,
                                        const size_t&           ,
                                        const type::frame_type& ,
                                        const unsigned&         ,
                                        const bool&             ,
                                        const addr* const&      ,
                                        const addr* const&      ,
                                        const bool&             )
      {
        ignore_ = false;
        try
          {
            growth_.update(frame.microseconds());
          }
        catch (const non_increasing_timestamp&)
          {
            std::cerr << frame << ": [addr_growth] Decreasing timestamp, "
                      << "ignoring." << std::endl;
            ignore_ = true;
          }
      }

      template <unsigned E, bool Tx>
      std::ostream&
      addr_growth<E, Tx>::print(std::ostream& os) const
      {
        return os << "begin MAC addr. growth\n"
                  << growth_
                  << "end MAC addr. growth\n";
      }

      template <unsigned E, bool Tx>
      void
      addr_growth<E, Tx>::restart()
      {
        growth_.restart();
      }

      /*--------------------.
      | beacon_items_growth |
      `--------------------*/

      template <unsigned E>
      beacon_items_growth<E>::beacon_items_growth(const void*): ignore_ (true)
      {
      }

      template <unsigned E>
      template <class Frame>
      void
      beacon_items_growth<E>::account_beacon(const Frame&               ,
                                             const addr* const&         ap,
                                             const addr* const&         bss,
                                             const optional_string&     ssid,
                                             const bool&                ibss)
      {
        if (ignore_)
          return;

        if (ap)
          ap_.update(*ap);
        if (bss)
          {
            if (ibss)
              ibssid_.update(*bss);
            else
              bssid_.update(*bss);
          }
        if (ssid)
          ssid_.update(*ssid);
      }

      template <unsigned E>
      template <class Frame>
      void
      beacon_items_growth<E>::account_frame(const Frame&                frame,
                                            const size_t&               ,
                                            const type::frame_type&     ,
                                            const unsigned&             ,
                                            const bool&                 ,
                                            const addr* const&          ,
                                            const addr* const&          ,
                                            const bool&                 )
      {
        const tool::microseconds& stamp = frame.microseconds();

        ignore_ = false;
        try
          {
            ap_.update(stamp);
            bssid_.update(stamp);
            ibssid_.update(stamp);
            ssid_.update(stamp);
          }
        catch (const non_increasing_timestamp&)
          {
            std::cerr << frame << ": [beacon_items_growth] Decreasing "
                      << "timestamp, ignoring." << std::endl;
            ignore_ = true;
          }
      }

      template <unsigned E>
      std::ostream&
      beacon_items_growth<E>::print(std::ostream& os) const
      {
        return os << "begin AP growth\n"
                  << ap_
                  << "end AP growth\n"
                  << '\n'
                  << "begin BSSID growth\n"
                  << bssid_
                  << "end BSSID growth\n"
                  << '\n'
                  << "begin IBSSID growth\n"
                  << ibssid_
                  << "end IBSSID growth\n"
                  << '\n'
                  << "begin SSID growth\n"
                  << ssid_
                  << "end SSID growth\n";
      }

      template <unsigned E>
      void
      beacon_items_growth<E>::restart()
      {
        ap_.restart();
        bssid_.restart();
        ibssid_.restart();
        ssid_.restart();
        ignore_ = true;
      }

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

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

#endif // ! WIFI_STATS_GROWTH_HXX_

---