include/wipal/wifi/seqctl.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_FRAME_SEQCTL_HXX_
# define WIFI_FRAME_SEQCTL_HXX_

# include "seqctl.hh"

namespace wpl
{

  namespace wifi
  {

    /*-------.
    | seqnum |
    `-------*/

    inline
    seqnum::seqnum(unsigned value): v_ (value)
    {
      assert(v_ < 4096);
    }

    inline
    unsigned
    seqnum::get() const
    {
      return v_;
    }

    inline
    bool
    seqnum::operator < (const seqnum& rhs) const
    {
      if (get() < rhs.get())
        return  rhs.get() - get() < 2048;
      else
        return  get() - rhs.get() > 2048;
    }

    inline
    bool
    seqnum::operator <= (const seqnum& rhs) const
    {
      return *this == rhs or *this < rhs;
    }

    inline
    bool
    seqnum::operator > (const seqnum& rhs) const
    {
      return not (*this <= rhs);
    }

    inline
    bool
    seqnum::operator >= (const seqnum& rhs) const
    {
      return not (*this < rhs);
    }

    inline
    bool
    seqnum::operator == (const seqnum& rhs) const
    {
      return get() == rhs.get();
    }

    inline
    bool
    seqnum::operator != (const seqnum& rhs) const
    {
      return not (*this == rhs);
    }

    inline
    int
    seqnum::operator - (const seqnum& rhs) const
    {
      if (get() < rhs.get())
        {
          const unsigned        d = rhs.get() - get();

          return d < 2048 ? -int (d) : int (4096 - d);
        }
      else
        {
          const unsigned        d = get() - rhs.get();

          return d > 2048 ? -int (4096 - d) : int (d);
        }
    }

    /*-------.
    | seqctl |
    `-------*/

    inline
    seqctl::seqctl(unsigned seqnum, unsigned fragnum)
    {
      assert(seqnum < 4096);
      assert(fragnum < 16);

      const uint16_t    t = (seqnum << 4) | fragnum;

      if (tool::need_swap(tool::end::little, false))
        seqctl_ = tool::extract_swapped_short_u(t);
      else
        seqctl_ = t;
    }

    inline
    seqctl::seqctl(const uint16_t raw): seqctl_ (raw)
    {
    }

    inline
    seqctl::seqctl(const void* raw):
      seqctl_ (*static_cast<const uint16_t*> (raw))
    {
    }

    inline
    seqnum
    seqctl::seqnum_get() const
    {
      return tool::extract_little_endian_short_u(seqctl_) >> 4;
    }

    inline
    unsigned
    seqctl::fragnum_get() const
    {
      return tool::extract_little_endian_short_u(seqctl_) & 0xF;
    }

    inline
    bool
    seqctl::operator < (const seqctl& rhs) const
    {
      const seqnum      l = seqnum_get();
      const seqnum      r = rhs.seqnum_get();

      if (l == r)
        return fragnum_get() < rhs.fragnum_get();

      return l < r;
    }

    inline
    bool
    seqctl::operator <= (const seqctl& rhs) const
    {
      return *this == rhs or *this < rhs;
    }

    inline
    bool
    seqctl::operator > (const seqctl& rhs) const
    {
      return not (*this <= rhs);
    }

    inline
    bool
    seqctl::operator >= (const seqctl& rhs) const
    {
      return not (*this < rhs);
    }

    inline
    bool
    seqctl::operator == (const seqctl& rhs) const
    {
      return seqctl_ == rhs.seqctl_;
    }

    inline
    bool
    seqctl::operator != (const seqctl& rhs) const
    {
      return not (*this == rhs);
    }


  } // End of namespace wpl::wifi.

} // End of namespace wpl.

#endif // ! WIFI_FRAME_SEQCTL_HXX_

---