ircproxy  The Ultimate Cyborg

---

Target.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file Target.h
//! @brief This file contains the declaration of class Target.
//
// Copyright (C) 2006, 2007 by
//
// Carlo Wood, Run on IRC <carlo@alinoe.com>
// RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
// Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
//
// This file may be distributed under the terms of the Q Public License
// version 1.0 as appearing in the file LICENSE.QPL included in the
// packaging of this file.

#ifndef TARGET_H
#define TARGET_H

#ifndef USE_PCH
#include <string>
#include <map>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
#include "debug.h"
#endif

#include "IRC_compare.h"

class ClientMessageIn;
class ServerMessageIn;
class Network;
class Identity;
class ClientSession;
class ServerSession;

/*! @brief An IRC message target (ie, channel or nickname), base class.
 *
 * This class represents the target that IRC messages can be targetted at.
 */
class Target {
protected:
  Network* M_network;                   //!< The underlying network.

protected:
  //! Protected constructor. Use Target::get to access a target by name.
  Target(Network* network) : M_network(network) { }

public:
  //! Destructor.
  virtual ~Target();

  //! Return the network that this target belongs to.
  Network const& network(void) const { return *M_network; }

  //! Return the network that this target belongs to.
  Network& network(void) { return *M_network; }

  virtual std::string in_name(ClientSession const&) const = 0;
  virtual std::string in_name(ServerSession const&) const = 0;
  virtual std::string out_name(ClientSession const&) const = 0;
  virtual std::string out_name(ServerSession const&) const = 0;

public:
  //! Add a (non-existent) new channel with name \a channel_name.
  // This function updates the target maps for this identity.
  // It should only be called for channels that the identity has joined.
  // The Channel is added with the same name to both sides (serverside and clientside).
  // \param identity The identity that joined this channel.
  // \param channel_name The channel name of the target. This is unique per network.
  static boost::shared_ptr<Channel> add_channel(Identity& identity, std::string const& channel_name);

  //! Remove this channel from the channel maps.
  //! Does the opposite of add_channel. Should only be called for channels that we have joined.
  void sub_channel(Identity& identity);

  static void serverside_add_channel(ServerSession& server_session, boost::shared_ptr<Channel> new_channel);

  //! Retrieve a shared pointer to the Channel object for \a channel_name.
  // \param identity The identity that needs this target at the moment.
  // \param channel_name The IRC name of the target. This is unique per network.
  static boost::shared_ptr<Channel> serverside_get_channel(Identity& identity, std::string const& channel_name, bool joined = false);

  //! Retrieve a shared pointer to the Channel object for \a channel_name.
  // \param identity The identity that needs this target at the moment.
  // \param channel_name The IRC name of the target. This is unique per network.
  static boost::shared_ptr<Channel> clientside_get_channel(Identity const& identity, std::string const& channel_name);

  //! Add a new nick with name \a nick_name to the joined channel with name \a channel_name.
  // This function updates the target maps for this identity.
  // It should only be called for channels that the identity has joined.
  // If the Nick isn't known already, then the Nick is added with the same name to both sides (serverside and clientside).
  // \param identity The identity that sees this nick join.
  // \param nick_name The serverside nick name of the joined target. This is unique per network.
  // \param channel_name The name of the channel that this nick joined.
  static boost::shared_ptr<Nick> add_joined_nick(Identity& identity, std::string const& nick_name, boost::shared_ptr<Channel>& channel);

  //! Return a shared pointer to the Nick object with name \a nick_name that is joined to channel \a channel.
  // If no such nick name exist, the exception unknown_target is thrown.
  static boost::shared_ptr<Nick> get_joined_nick(Identity& identity, std::string const& nick_name, boost::shared_ptr<Channel>& channel);

public:
  //! This is called when a new message targetted at this target is received.
  virtual void new_client_message_received(ClientMessageIn const&) = 0;
  //! This is called when a new message targetted at this target is received.
  virtual void new_server_message_received(ServerMessageIn const&) = 0;

#ifdef CWDEBUG
protected:
  virtual bool is_me(void) const { return false; }
#endif
};

//! The type of the target maps that are used for mapping the target names to the real object.
typedef std::map<std::string, boost::weak_ptr<Target>, IRC_less> target_lookup_map_type;

//! The type of the target maps that are used to keep targets alive.
typedef std::map<std::string, boost::shared_ptr<Target>, IRC_less> target_hold_map_type;

#endif // TARGET_H

---