include/wipal/wifi/unique_id/unique_id.hh

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

# include <ostream>
# include <boost/optional.hpp>

# include <wipal/pcap/pkt.hh>
# include <wipal/wifi/addr_mapping.hh>
# include <wipal/tool/hash.hh>

namespace wpl
{

  namespace wifi
  {

    namespace internals
    {
      struct tag1 {};
      struct tag2 {};
      struct tag3 {};
      struct tag4 {};

      template <class Tag>
      struct empty
      {
        bool operator  < (const empty& rhs) const;
        bool operator == (const empty& rhs) const;
        bool operator != (const empty& rhs) const;
      };

      template <class T, class Tag = tag1>
      struct adapter
      {
        adapter(const T& v = T());

        bool operator  < (const adapter& rhs) const;
        bool operator == (const adapter& rhs) const;
        bool operator != (const adapter& rhs) const;

        const T&        value() const;
        T&              value();

      private:
        T       v_;
      };

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

    template < class Id1 = internals::empty<internals::tag1>,
               class Id2 = internals::empty<internals::tag2>,
               class Id3 = internals::empty<internals::tag3>,
               class Id4 = internals::empty<internals::tag4> >
    struct unique_id: private Id1, private Id2, private Id3, private Id4
    {
      unique_id(unsigned        frame_id,
                const Id1&      id1 = Id1 (),
                const Id2&      id2 = Id2 (),
                const Id3&      id3 = Id3 (),
                const Id4&      id4 = Id4 ());


      bool              operator < (const unique_id& rhs) const;
      bool              operator == (const unique_id& rhs) const;
      bool              operator != (const unique_id& rhs) const;

      std::ostream&     print(std::ostream&) const;

      unsigned          frame_id() const;


      const Id1&        id1() const;
      const Id2&        id2() const;
      const Id3&        id3() const;
      const Id4&        id4() const;

    private:
      unsigned          frame_id_;
    };

    template <class Id1, class Id2, class Id3, class Id4>
    std::ostream&
    operator << (std::ostream&, const unique_id<Id1, Id2, Id3, Id4>&);

    template <class UniqueId>
    struct unique_id_factory;

# define WP_UNIQUE_ID_DISSECT(F, D, HType, H)                   \
    dissector<HType>    D = dissect<HeaderType, HType>(F);      \
    const HType&        H = D.hooks()

  } // End of namespace wpl::wifi.

} // End of namespace wpl.

/*---------------.
| Hash functions |
`---------------*/

WP_HASH_NAMESPACE_BEGIN

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

  template <class T, class Tag>
  struct hash< wpl::wifi::internals::adapter<T, Tag> >: public hash<T>
  {
    size_t
    operator () (const wpl::wifi::internals::adapter<T, Tag>&) const;
  };

  template <class Id1, class Id2, class Id3, class Id4>
  struct hash< wpl::wifi::unique_id<Id1, Id2, Id3, Id4> >:
      public hash<Id1>,
      public hash<Id2>,
      public hash<Id3>,
      public hash<Id4>
  {
    size_t
    operator () (const wpl::wifi::unique_id<Id1, Id2, Id3, Id4>&) const;
  };

WP_HASH_NAMESPACE_END


# include "unique_id.hxx"

#endif // ! WIFI_UNIQUE_ID_HH_

---