PacketHandler.hh

Go to the documentation of this file.

/*
** TowBowlTactics, an adaptation of the tabletop game Blood Bowl.
** 
** Copyright (C) 2006, 2007 The TBT Team.
** 
** 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.
** 
** The complete GNU General Public Licence Notice can be found as the
** `NOTICE' file in the root directory.
** 
** The TBT Team consists of people listed in the `AUTHORS' file.
*/

#ifndef PACKETHANDLER_HH_
# define PACKETHANDLER_HH_


# include "tools.hh"
# include "EventProcess.hh"

class BasePacketHandler
{
public:
  virtual ~BasePacketHandler() {}
  virtual void handle(const Packet* p) = 0;
  virtual int getCstValue() const = 0;
  virtual void dispatchUIEvent(const EventProcess* evp,
                               const Packet& pkt) = 0;
};

template <int N, typename T>
class PacketHandler : public BasePacketHandler
{
};

# define DECLARE_PACKET(Cst, PClass)                            \
struct PClass;                                                  \
template <typename T>                                           \
class PacketHandler<Cst, T> : public BasePacketHandler          \
{                                                               \
public:                                                         \
  typedef void (T::*fct_t)(const PClass*);                      \
  PacketHandler<Cst, T>(T* obj, fct_t f)                        \
    : obj_(obj), f_(f) {}                                       \
  virtual void handle(const Packet* p)                          \
  {                                                             \
    LOG5("<- `" #Cst "' (id: %1)",                              \
         p->client_id);                                         \
    (obj_->*f_)(reinterpret_cast<const PClass*>(p));            \
  }                                                             \
  virtual int getCstValue() const { return Cst; }               \
  virtual void dispatchUIEvent(const EventProcess* evp,         \
                               const Packet& pkt)               \
  {                                                             \
    evp->dispatch(reinterpret_cast<const PClass&>(pkt));        \
  }                                                             \
private:                                                        \
  T* obj_;                                                      \
  fct_t f_;                                                     \
};                                                              \
struct PClass : public Packet                                   \
{                                                               \
  PClass(int client_id = -1)                                    \
   : Packet(Cst, client_id) { data_size = sizeof(*this); }

// Ugly. To have balanced braces.
# define END_PACKET };

# define DECLARE_EMPTY_PACKET(Cst, PClass)      \
  DECLARE_PACKET(Cst, PClass)                   \
  END_PACKET 

# define HANDLE_WITH(Token, Class, Object, Method, When)                \
  handleWith(new PacketHandler<Token, Class>(Object, &Class::Method), When)


#endif /* !PACKETHANDLER_HH_ */

---