include/wipal/wifi/stats/on_off_data.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_ON_OFF_DATA_HXX_
# define WIFI_STATS_ON_OFF_DATA_HXX_

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

namespace wpl
{

  namespace wifi
  {

    namespace stats
    {

      on_off_data::on_off_data(const void*): trace_ (0),
                                             last_stamps_ (1, 0)
      {
      }

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

        last_stamps_[trace_] = t;

        if (not transmitter)
          return;

        const state_id          id (trace_, *transmitter);
        const states::iterator  i = states_.find(id);

        if (i == states_.end())
          {
            states_.insert(std::make_pair(id, t));
            return;
          }

        state&                          s = i->second;
        tool::microseconds&             last_seen = s.last_seen;
        const tool::microseconds        expiration_time = (last_seen +
                                                           state::lifetime);

        if (expiration_time < t)
          {
            s.events.push_back(expiration_time);
            s.events.push_back(t);
          }
        last_seen = t;
      }

      inline
      void
      on_off_data::restart()
      {
        ++trace_;
        last_stamps_.push_back(0);
      }

      inline
      std::ostream&
      on_off_data::print(std::ostream& os) const
      {
        os << "begin ON/OFF events\n\n";

        BOOST_FOREACH(const states::const_iterator::value_type& p, states_)
          {
            os << "  begin ON/OFF T" << p.first.first
               << " STA " << p.first.second << '\n';

            bool        state (false);

            BOOST_FOREACH(const tool::microseconds& t, p.second.events)
              {
                state = not state;
                os << "    " << t << '\t' << state << '\n';
              }
            assert(state);

            const tool::microseconds    expiration_time = (p.second.last_seen +
                                                           state::lifetime);
            if (expiration_time < last_stamps_[p.first.first])
              os << "    " << expiration_time << "\t0\n";

            os << "  end ON/OFF T" << p.first.first
               << " STA " << p.first.second << "\n\n";
          }
        return os << "end ON/OFF events" << std::endl;
      }

      inline
      tool::microseconds
      on_off_data::time_on(const addr& sta) const
      {
        typedef std::vector<tool::microseconds> events_type;
        typedef events_type::const_iterator     events_iterator;

        tool::microseconds      r = 0;

        for (unsigned t = 0; t <= trace_; ++t)
          {
            const states::const_iterator  s = states_.find(state_id (t, sta));

            if (s == states_.end())
              continue;

            const events_type&  events = s->second.events;

            assert(not events.empty());

            events_iterator     e = events.begin();
            tool::microseconds  start = *e++;

            while (e != events.end())
              {
                r += *e++ - start;
                assert(e != events.end());
                start = *e++;
              }

            /* Read the following std::min(...) expression as
             * "min(last_active, end_of_trace)".  We need this to
             * avoid accounting the activity of a STA after the trace
             * has ended.
             */
            r += std::min(tool::microseconds (s->second.last_seen +
                                              state::lifetime),
                          last_stamps_[t]) - start;
          }
        return r;
      }

      inline
      on_off_data::state::state(const tool::microseconds& first_seen):
        last_seen (first_seen)
      {
        events.push_back(first_seen);
      }

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

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

#endif // ! WIFI_STATS_ON_OFF_DATA_HXX_

---