include/wipal/phy/timetracker.hxx

/*
 * 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 PHY_TIMETRACKER_HXX_
# define PHY_TIMETRACKER_HXX_

# include <boost/optional.hpp>

# include <wipal/tool/gmp_64_wrapper.hh>

# include "timetracker.hh"

namespace wpl
{

  namespace phy
  {

    template <class B>
    timetracker<B>::timetracker(bool force_pcap): last_stamp_ (0),
                                                  ms_count_ (0),
                                                  force_pcap_ (force_pcap)
    {
    }

    template <class B>
    template <class UIntType>
    void
    timetracker<B>::tick_uint(UIntType ts)
    {
      const UIntType            half_range (UIntType (1)
                                            << (sizeof (ts) * 8 - 1));
      const tool::microseconds  ms_ts (ts);
      const tool::microseconds  ms_last_stamp (last_stamp_);

      ms_count_ += ms_ts - ms_last_stamp;
      if (ts < last_stamp_ and last_stamp_ - ts > half_range)
        {
          static boost::optional<tool::microseconds> range;

          if (not range)
            {
              range = 1;
              *range <<= sizeof (ts) * 8;
            }

          ms_count_ += *range;
        }
      last_stamp_ = ts;
    }

    template <class B>
    void
    timetracker<B>::tick_tv(const struct timeval& tv)
    {
      ms_count_ = tool::microseconds (tv);
    }

    namespace internals
    {

      template <class I, class B>
      struct tick_switch
      {
        template <class S>
        static void     tick(timetracker<B>&            trk,
                             const pkt::packet<S>&      p,
                             const I&                   )
        {
          trk.tick_tv(p.meta().ts);
        }
      };

      template <class B>
      struct tick_switch<uint32_t, B>
      {
        template <class S>
        static void     tick(timetracker<B>&            trk,
                             const pkt::packet<S>&      ,
                             uint32_t                   ts)
        {
          trk.tick_uint(ts);
        }
      };

      template <class B>
      struct tick_switch<uint64_t, B>
      {
        template <class S>
        static void     tick(timetracker<B>&            trk,
                             const pkt::packet<S>&      ,
                             uint64_t                   ts)
        {
          trk.tick_uint(ts);
        }
      };

      template <class B>
      struct tick_switch<struct timeval, B>
      {
        template <class S>
        static void     tick(timetracker<B>&            trk,
                             const pkt::packet<S>&      ,
                             const struct timeval&      tv)
        {
          trk.tick_tv(tv);
        }
      };

    } // End of namespace wifi::internals.

    template <class B>
    template <class HT, class S>
    void
    timetracker<B>::tick(const pkt::packet<S>&  frame,
                         tool::end::endianness  phy_end)
    {
      const pkt::metadata& m = frame.meta();

      if (force_pcap_)
        {
          tick_tv(m.ts);
          return;
        }

      const bool        swap = tool::need_swap(phy_end, frame.swapped());
      const HT* const   bytes = static_cast<const HT*> (frame.bytes());

      if (m.caplen < bytes->len(m.caplen, swap))
        return;

      internals::tick_switch<typename HT::time_type::impl_type, B>::
	tick(*this, frame, bytes->time_get(swap).get());
    }

    template <class B>
    tool::microseconds
    timetracker<B>::microseconds() const
    {
      return ms_count_;
    }

  } // End of namespace wpl::phy.

} // End of namespace wpl.

#endif // ! PHY_TIMETRACKER_HXX_

---