include/wipal/phy/prism_header.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 PRISM_HEADER_HXX_
# define PRISM_HEADER_HXX_

# include "prism_header.hh"

# include <wipal/tool/endianness.hh>

namespace wpl
{

  namespace prism
  {

    /*------------.
    | prism::item |
    `------------*/

    inline
    uint32_t
    item::get(bool swapped) const
    {
      return tool::extract_long_u(data, swapped);
    }

    inline
    item&
    item::set(uint32_t value, bool swapped)
    {
      status = 0;
      data = tool::extract_long_u(value, swapped);

      return *this;
    }

    /*------------.
    | prism::time |
    `------------*/

    inline
    time::time(): mactime_ (0), hosttime_ (0)
    {
    }

    inline
    time::time(uint32_t mactime, uint32_t hosttime): mactime_ (mactime),
                                                     hosttime_ (hosttime)
    {
    }

    inline
    uint32_t
    time::mactime() const
    {
      return mactime_;
    }

    inline
    uint32_t
    time::hosttime() const
    {
      return hosttime_;
    }

    inline
    time::impl_type
    time::get_impl() const
    {
      return mactime();
    }

    inline
    time::exact_type&
    time::increment(tool::microseconds ms)
    {
      const tool::microseconds::mpz_type        mpz_hosttime = hosttime_;
      const tool::microseconds          ms_mactime   = ms + mactime_;
      const tool::microseconds          ms_hosttime  = ms + mpz_hosttime * 10;

      mactime_  = ms_mactime.get_prism_mactime();
      hosttime_ = ms_hosttime.get_prism_hosttime();

      return this->exact();
    }

    /*--------------.
    | prism::header |
    `--------------*/


    inline
    size_t
    header::len_impl(size_t, bool) const
    {
      return sizeof (*this);
    }

    inline
    header::time_type
    header::time_get_impl(bool swapped) const
    {
      return time_type (mactime.get(swapped), hosttime.get(swapped));
    }

    inline
    void
    header::time_set_impl(const time_type& value, bool swapped)
    {
      mactime.set(value.mactime(), swapped);
      hosttime.set(value.hosttime(), swapped);
    }

    template <class S1, class S2>
    bool
    header::eq_time(const pkt::packet<S1>&              lhs,
                    const pkt::packet<S2>&              rhs,
                    const unsigned                      prec,
                    const tool::end::endianness         phy_end)
    {
      using tool::need_swap;

      const pkt::metadata&      lhs_meta = lhs.meta();
      const pkt::metadata&      rhs_meta = rhs.meta();

      const size_t              caplen = std::min(lhs_meta.caplen,
                                                  rhs_meta.caplen);

      if (caplen < sizeof (prism::header))
        return false;

      const bool                lhs_sw = need_swap(phy_end, lhs.swapped());
      const bool                rhs_sw = need_swap(phy_end, rhs.swapped());

      const header* const       lhs_phy = (static_cast<const header*>
                                           (lhs.bytes()));
      const header* const       rhs_phy = (static_cast<const header*>
                                           (rhs.bytes()));


      return unsigned (std::abs(int (lhs_phy->mactime.get(lhs_sw) -
                                     rhs_phy->mactime.get(rhs_sw)))) <= prec;
    }

  } // End of namespace wpl::prism.

} // End of namespace wpl.

#endif // ! PRISM_HEADER_HXX_

---