include/wipal/wifi/unique_id/unique_id.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_UNIQUE_ID_HXX_
# define WIFI_UNIQUE_ID_HXX_

# include "unique_id.hh"

namespace wpl
{

  namespace wifi
  {

    namespace internals
    {

      template <class Tag>
      bool
      empty<Tag>::operator < (const empty&) const
      {
        return false;
      }

      template <class Tag>
      bool
      empty<Tag>::operator == (const empty&) const
      {
        return true;
      }

      template <class Tag>
      bool
      empty<Tag>::operator != (const empty&) const
      {
        return false;
      }

      template <class T, class Tag>
      adapter<T, Tag>::adapter(const T& v): v_ (v)
      {
      }

      template <class T, class Tag>
      bool
      adapter<T, Tag>::operator < (const adapter& rhs) const
      {
        return v_ < rhs.v_;
      }

      template <class T, class Tag>
      bool
      adapter<T, Tag>::operator == (const adapter& rhs) const
      {
        return v_ == rhs.v_;
      }

      template <class T, class Tag>
      bool
      adapter<T, Tag>::operator != (const adapter& rhs) const
      {
        return not (*this == rhs);
      }

      template <class T, class Tag>
      const T&
      adapter<T, Tag>::value() const
      {
        return v_;
      }

      template <class T, class Tag>
      T&
      adapter<T, Tag>::value()
      {
        return v_;
      }

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

    /*----------------------.
    | uniquely_identifiable |
    `----------------------*/

    template <class Id1, class Id2, class Id3, class Id4>
    unique_id<Id1, Id2, Id3, Id4>::unique_id(unsigned   frame_id,
                                             const Id1& id1,
                                             const Id2& id2,
                                             const Id3& id3,
                                             const Id4& id4):
      Id1 (id1),
      Id2 (id2),
      Id3 (id3),
      Id4 (id4),
      frame_id_ (frame_id)
    {
    }

    template <class Id1, class Id2, class Id3, class Id4>
    bool
    unique_id<Id1, Id2, Id3, Id4>::operator < (const unique_id& rhs) const
    {
      const Id1&   l1 = id1(),   r1 = rhs.id1();
      const Id2&   l2 = id2(),   r2 = rhs.id2();
      const Id3&   l3 = id3(),   r3 = rhs.id3();
      const Id4&   l4 = id4(),   r4 = rhs.id4();

      if (l1 != r1)
        return l1 < r1;
      if (l2 != r2)
        return l2 < r2;
      if (l3 != r3)
        return l3 < r3;
      return l4 < r4;
    }

    template <class Id1, class Id2, class Id3, class Id4>
    bool
    unique_id<Id1, Id2, Id3, Id4>::operator == (const unique_id& rhs) const
    {
      return (id1() == rhs.id1() and id2() == rhs.id2() and
              id3() == rhs.id3() and id4() == rhs.id4());
    }

    template <class Id1, class Id2, class Id3, class Id4>
    bool
    unique_id<Id1, Id2, Id3, Id4>::operator != (const unique_id& rhs) const
    {
      return not (*this == rhs);
    }

    template <class Id1, class Id2, class Id3, class Id4>
    std::ostream&
    unique_id<Id1, Id2, Id3, Id4>::print(std::ostream& os) const
    {
      return os << frame_id_;
    }

    template <class Id1, class Id2, class Id3, class Id4>
    unsigned
    unique_id<Id1, Id2, Id3, Id4>::frame_id() const
    {
      return frame_id_;
    }

    template <class Id1, class Id2, class Id3, class Id4>
    const Id1&
    unique_id<Id1, Id2, Id3, Id4>::id1() const
    {
      return static_cast<const Id1&> (*this);
    }

    template <class Id1, class Id2, class Id3, class Id4>
    const Id2&
    unique_id<Id1, Id2, Id3, Id4>::id2() const
    {
      return static_cast<const Id2&> (*this);
    }

    template <class Id1, class Id2, class Id3, class Id4>
    const Id3&
    unique_id<Id1, Id2, Id3, Id4>::id3() const
    {
      return static_cast<const Id3&> (*this);
    }

    template <class Id1, class Id2, class Id3, class Id4>
    const Id4&
    unique_id<Id1, Id2, Id3, Id4>::id4() const
    {
      return static_cast<const Id4&> (*this);
    }

    template <class Id1, class Id2, class Id3, class Id4>
    std::ostream&
    operator << (std::ostream& os, const unique_id<Id1, Id2, Id3, Id4>& ui)
    {
      return ui.print(os);
    }

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

WP_HASH_NAMESPACE_BEGIN

  template <class Tag>
  size_t
  hash< wpl::wifi::internals::empty<Tag> >::
  operator () (const wpl::wifi::internals::empty<Tag>&) const
  {
    return 0;
  }

  template <class T, class Tag>
  size_t
  hash< wpl::wifi::internals::adapter<T, Tag> >::
  operator () (const wpl::wifi::internals::adapter<T, Tag>& a) const
  {
    return hash<T>::operator () (a.value());
  }

  template <class Id1, class Id2, class Id3, class Id4>
  size_t
  hash< wpl::wifi::unique_id<Id1, Id2, Id3, Id4> >::
  operator () (const wpl::wifi::unique_id<Id1, Id2, Id3, Id4>& i) const
  {
    return (hash<Id1>::operator () (i.id1()) ^
            hash<Id2>::operator () (i.id2()) ^
            hash<Id3>::operator () (i.id3()) ^
            hash<Id4>::operator () (i.id4()));
  }

WP_HASH_NAMESPACE_END

#endif // ! WIFI_UNIQUE_ID_HXX_

---