include/wipal/wifi/timestamp.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 WIFI_TIMESTAMP_HXX_
# define WIFI_TIMESTAMP_HXX_

# include <algorithm>
# include <stack>

# include <boost/array.hpp>

# include "timestamp.hh"

namespace wpl
{

  namespace wifi
  {

    inline
    timestamp::timestamp()
    {
#ifndef NDEBUG
      std::fill(digits_.begin(), digits_.end(), 0);
#endif // ! NDEBUG
    }

    inline
    timestamp::timestamp(uint32_t hi, uint32_t lo)
    {
      digits_[0] = (lo & 0x000000FF) >> 0;
      digits_[1] = (lo & 0x0000FF00) >> 8;
      digits_[2] = (lo & 0x00FF0000) >> 16;
      digits_[3] = (lo & 0xFF000000) >> 24;
      digits_[4] = (hi & 0x000000FF) >> 0;
      digits_[5] = (hi & 0x0000FF00) >> 8;
      digits_[6] = (hi & 0x00FF0000) >> 16;
      digits_[7] = (hi & 0xFF000000) >> 24;
    }

    inline
    bool
    timestamp::operator == (const timestamp& rhs) const
    {
      return digits_ == rhs.digits_;
    }

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

    inline
    bool
    timestamp::operator < (const timestamp& rhs) const
    {
      return
        std::lexicographical_compare(digits_.rbegin(), digits_.rend(),
                                     rhs.digits_.rbegin(), rhs.digits_.rend());
    }

    inline
    std::ostream&
    timestamp::print(std::ostream& os) const
    {
      // FIXME: We could optimize here using uint64_t or performing
      //              a 32-bit-digits division.  However we do not want to
      //              bloat the code with endiannes issues.

      digits_t          tmp;
      std::stack<char>  out;

      std::copy(digits_.begin(), digits_.end(), tmp.rbegin());
      while (true)
        {
          digits_t::iterator    i = tmp.begin();
          unsigned              carry = 0;

          // Skip leading 0's.
          while (i != tmp.end() and not *i)
            ++i;

          // Exit loop if tmp = 0.
          if (i == tmp.end())
            break;

          // Divide by 10.
          while (i != tmp.end())
            {
              carry = (carry << (sizeof (*i) * 8)) + *i;
              *i = carry / 10;
              carry = carry % 10;
              ++i;
            }
          out.push(carry + '0');
        }

      if (out.empty())
        return os << "0";
      while (not out.empty())
        {
          os << out.top();
          out.pop();
        }
      return os;
    }

    inline
    size_t
    timestamp::hash() const
    {
      return *reinterpret_cast<const size_t*> (digits_.data());
    }

    inline
    std::ostream&
    operator << (std::ostream& os, const timestamp& ts)
    {
      return ts.print(os);
    }

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

WP_HASH_NAMESPACE_BEGIN

  inline
  size_t
  hash<wpl::wifi::timestamp>::operator () (const wpl::wifi::timestamp& t) const
  {
    return t.hash();
  }

WP_HASH_NAMESPACE_END

#endif // ! WIFI_TIMESTAMP_HXX_

---