Target Class Reference

#include <Target.h>

Inheritance diagram for Target:

List of all members.

---

Detailed Description

An IRC message target (ie, channel or nickname), base class.

This class represents the target that IRC messages can be targetted at.

Definition at line 40 of file Target.h.

Public Member Functions
virtual	~Target ()
	Destructor.
Network const &	network (void) const
	Return the network that this target belongs to.
Network &	network (void)
	Return the network that this target belongs to.
void	sub_channel (Identity &identity)
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
	This is called when a new message targetted at this target is received.
Static Public Member Functions
static boost::shared_ptr< Channel >	add_channel (Identity &identity, std::string const &channel_name)
	Add a (non-existent) new channel with name channel_name.
static void	serverside_add_channel (ServerSession &server_session, boost::shared_ptr< Channel > new_channel)
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 channel_name.
static boost::shared_ptr< Channel >	clientside_get_channel (Identity const &identity, std::string const &channel_name)
	Retrieve a shared pointer to the Channel object for channel_name.
static boost::shared_ptr< Nick >	add_joined_nick (Identity &identity, std::string const &nick_name, boost::shared_ptr< Channel > &channel)
	Add a new nick with name nick_name to the joined channel with name channel_name.
static boost::shared_ptr< Nick >	get_joined_nick (Identity &identity, std::string const &nick_name, boost::shared_ptr< Channel > &channel)
	Return a shared pointer to the Nick object with name nick_name that is joined to channel channel.
Protected Member Functions
	Target (Network *network)
	Protected constructor. Use Target::get to access a target by name.
Protected Attributes
Network *	M_network
	The underlying network.

---

Constructor & Destructor Documentation

Target::Target

(

Network *

network

)

[inline, protected]

Protected constructor. Use Target::get to access a target by name.

Definition at line 46 of file Target.h.

: M_network(network) { }

Target::~Target

(

)

[virtual]

Destructor.

Definition at line 30 of file Target.cc.

References ASSERT, Network::is_private(), M_network, debug::channels::dc::maps, Network::name(), debug::channels::dc::objects, and Network::targets().

{
#if 0 // FIXME
  ASSERT(!debug::secondary_connection);
  Dout(dc::objects, "Destructing Target \"" << M_serverside_name << "\" of network \"" << M_network->name() << "\".");
  // Of course, we also get here for private targets; however -- private targets
  // are never added to M_network.targets() (see assertion in Target::add).
  if (!M_network->is_private())
  {
    target_lookup_map_type::iterator iter = M_network->targets().find(M_serverside_name); 
    // This map only contains targets that are on common channels.
    if (iter != M_network->targets().end())
    {
      Dout(dc::maps, "Erasing " << M_serverside_name << " from Network map.");
      M_network->targets().erase(iter);
    }
#ifdef CWDEBUG
    else
      Dout(dc::notice, "Could not find \"" << M_serverside_name << "\" in network map " << M_network->targets());
#endif
  }
#endif
}

---

Member Function Documentation

Network const& Target::network

(

void

)

const [inline]

Return the network that this target belongs to.

Definition at line 53 of file Target.h.

References M_network.

Referenced by add_channel(), add_joined_nick(), and get_joined_nick().

{ return *M_network; }

Network& Target::network

(

void

)

[inline]

Return the network that this target belongs to.

Definition at line 56 of file Target.h.

References M_network.

{ return *M_network; }

boost::shared_ptr< Channel > Target::add_channel	(	Identity &	identity,
		std::string const &	channel_name
	)			[static]

Add a (non-existent) new channel with name channel_name.

Definition at line 136 of file Target.cc.

References ASSERT, Identity::client_session(), DoutEntering, is_channel(), ClientSession::joined_channels(), ServerSession::joined_channels(), debug::channels::dc::maps, ServerConnection::network(), network(), Identity::server_connection(), Identity::server_session(), serverside_add_channel(), and Network::targets().

Referenced by serverside_get_channel().

{
  ASSERT(!debug::secondary_connection);
  DoutEntering(dc::maps|dc::debug, "Target::add_channel(" << identity << ", \"" << channel_name << "\")");
  // A new channel is always added on both, server and client side with the same name.
#ifdef CWDEBUG
  ASSERT(is_channel(channel_name));
  ServerSession::joined_channels_type::iterator iter1 = identity.server_session().joined_channels().find(channel_name);
  ClientSession::joined_channels_type::iterator iter2 = identity.client_session().joined_channels().find(channel_name);
  ASSERT(iter1 == identity.server_session().joined_channels().end() &&
         iter2 == identity.client_session().joined_channels().end());
#endif
  boost::shared_ptr<Channel> new_channel;
  Network& network(identity.server_connection().network());
  target_lookup_map_type::iterator network_iter = network.targets().find(channel_name);
  if (network_iter != network.targets().end())
    new_channel = boost::static_pointer_cast<Channel>(network_iter->second.lock());
  else
  {
    Channel* channel = new Channel(identity, channel_name, network);
    AllocTag(channel, channel_name);
    new_channel.reset(channel);
  }
  Target::serverside_add_channel(identity.server_session(), new_channel);
  Dout(dc::maps, "Inserting " << channel_name << " in clientside joined_channels map.");
#if defined(CWDEBUG) || defined(DEBUG)
  std::pair<ClientSession::joined_channels_type::iterator, bool> clientside_res =
#endif
      identity.client_session().joined_channels().insert(ClientSession::joined_channels_type::value_type(channel_name, new_channel));
  ASSERT(clientside_res.second);
  return new_channel;
}

void Target::sub_channel

(

Identity &

identity

)

Remove this channel from the channel maps. Does the opposite of add_channel. Should only be called for channels that we have joined.

Definition at line 169 of file Target.cc.

References ASSERT, Identity::client_session(), DoutEntering, is_channel(), ClientSession::joined_channels(), ServerSession::joined_channels(), debug::channels::dc::maps, Channel::members(), Identity::mynick(), Identity::server_session(), and Channel::sub_joined_nick().

Referenced by Channel::new_server_message_received().

{
#if 0 // FIXME
  ASSERT(!debug::secondary_connection);
  DoutEntering(dc::maps|dc::debug, "Target::sub_channel(" << identity << ") for " << *this);
  ASSERT(is_channel(M_serverside_name));
  Channel& channel(*static_cast<Channel*>(this));
  channel.sub_joined_nick(identity.mynick());
  for (Channel::members_type::iterator iter = channel.members().begin(); iter != channel.members().end(); ++iter)
    iter->second.get_nick()->sub_channel(channel);
  ServerSession::joined_channels_type::iterator iter1 = identity.server_session().joined_channels().find(M_serverside_name);
  ClientSession::joined_channels_type::iterator iter2 = identity.client_session().joined_channels().find(M_clientside_name);
  ASSERT(iter1 != identity.server_session().joined_channels().end() &&
         iter2 != identity.client_session().joined_channels().end());
  Dout(dc::maps, "Erasing " << M_serverside_name << " from serverside joined_channels map.");
  identity.server_session().joined_channels().erase(iter1);
  Dout(dc::maps, "Erasing " << M_clientside_name << " from clientside joined_channels map.");
  identity.client_session().joined_channels().erase(iter2);
#endif
}

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

For internal use only.

Definition at line 116 of file Target.cc.

References ASSERT, is_channel(), ServerSession::joined_channels(), debug::channels::dc::maps, ServerConnection::network(), ServerSession::server_connection(), and Network::targets().

Referenced by add_channel(), and ServerSession::new_message_received().

{
#if 0
  std::string channel_name(new_channel->serverside_name());
  ASSERT(is_channel(channel_name));
  std::pair<target_lookup_map_type::iterator, bool> res =
      server_session.server_connection().network().targets().insert(target_lookup_map_type::value_type(channel_name, new_channel));
#ifdef CWDEBUG
  if (res.second)
    Dout(dc::maps, "Inserted " << channel_name << " in Network map.");
#endif
  Dout(dc::maps, "Inserting " << channel_name << " in serverside joined_channels map.");
#if defined(CWDEBUG) || defined(DEBUG)
  std::pair<ClientSession::joined_channels_type::iterator, bool> serverside_res =
#endif
    server_session.joined_channels().insert(ServerSession::joined_channels_type::value_type(channel_name, new_channel));
  ASSERT(serverside_res.second);
#endif
}

boost::shared_ptr< Channel > Target::serverside_get_channel	(	Identity &	identity,
		std::string const &	channel_name,
		bool	joined = false
	)			[static]

Retrieve a shared pointer to the Channel object for channel_name.

Definition at line 190 of file Target.cc.

References add_channel(), ASSERT, is_channel(), ServerSession::joined_channels(), Identity::key(), Identity::server_session(), and THROW_EXCEPTION.

Referenced by Identity::new_server_message_received(), and Channel::new_server_message_received().

{
  ASSERT(!debug::secondary_connection);
  ASSERT(is_channel(channel_name));

  // Search in the serverside channels map of this session.
  ServerSession::joined_channels_type::iterator iter =
      (channel_name[0] == '@') ? identity.server_session().joined_channels().find(channel_name.substr(1))
                               : identity.server_session().joined_channels().find(channel_name);
  if (iter != identity.server_session().joined_channels().end())
    return boost::static_pointer_cast<Channel>(iter->second);

  if (joined)
    return Target::add_channel(identity, channel_name);

  THROW_EXCEPTION(unknown_target(), "The identity " << identity.key() << " has no server side channel \"" << channel_name << "\"");
}

boost::shared_ptr< Channel > Target::clientside_get_channel	(	Identity const &	identity,
		std::string const &	channel_name
	)			[static]

Retrieve a shared pointer to the Channel object for channel_name.

Definition at line 208 of file Target.cc.

References ASSERT, Identity::client_session(), is_channel(), ClientSession::joined_channels(), Identity::key(), ClientSession::private_targets(), and THROW_EXCEPTION.

Referenced by Identity::new_client_message_received().

{
  ASSERT(!debug::secondary_connection);
  ASSERT(is_channel(channel_name));

  // First search in the map with private channels.
  ClientSession::private_targets_type::const_iterator priv_iter = identity.client_session().private_targets().find(channel_name);
  if (priv_iter != identity.client_session().private_targets().end())
    return boost::static_pointer_cast<Channel>(priv_iter->second);
  
  // If we still didn't find it, search in the clientside channels map of this session.
  ClientSession::joined_channels_type::const_iterator iter = identity.client_session().joined_channels().find(channel_name);
  if (iter != identity.client_session().joined_channels().end())
    return boost::static_pointer_cast<Channel>(iter->second);

  THROW_EXCEPTION(unknown_target(), "The identity " << identity.key() << " has no client side channel \"" << channel_name << "\"");
}

boost::shared_ptr< Nick > Target::add_joined_nick	(	Identity &	identity,
		std::string const &	nick_name,
		boost::shared_ptr< Channel > &	channel
	)			[static]

Add a new nick with name nick_name to the joined channel with name channel_name.

Definition at line 73 of file Target.cc.

References ASSERT, DoutEntering, is_nick(), Network::is_private(), debug::channels::dc::maps, ServerConnection::network(), network(), Identity::server_connection(), and Network::targets().

Referenced by Identity::new_server_message_received(), and Channel::new_server_message_received().

{
#if 0
  ASSERT(!debug::secondary_connection);
  DoutEntering(dc::maps|dc::debug, "Target::add_joined_nick(" << identity << ", \"" << nick_name << "\", \"" << channel->serverside_name() << "\")");
  ASSERT(is_nick(nick_name));

  boost::shared_ptr<Nick> new_nick;
  // Get the network.
  Network& network(identity.server_connection().network());
  ASSERT(!network.is_private());
  // Get the nick, if any, or else create one.
  target_lookup_map_type::iterator network_iter = network.targets().find(nick_name);
  if (network_iter != network.targets().end())
    new_nick = boost::static_pointer_cast<Nick>(network_iter->second.lock());
  else
  {
    Nick* nick = new Nick(identity, nick_name, network);
    AllocTag(nick, nick_name);
    new_nick.reset(nick);
    Dout(dc::maps, "Inserting " << nick_name << " in Network map.");
#if defined(CWDEBUG) || defined(DEBUG)
    std::pair<target_lookup_map_type::iterator, bool> res =
#endif
        network.targets().insert(target_lookup_map_type::value_type(nick_name, new_nick));
    ASSERT(res.second);
  }
  // Add the new nick to this channel.
  Dout(dc::maps, "Adding nick " << nick_name << " as member to " << channel->serverside_name());
#if defined(CWDEBUG) || defined(DEBUG)
  std::pair<Channel::members_type::iterator, bool> res =
#endif
      channel->members().insert(Channel::members_type::value_type(nick_name, Member(new_nick)));
  ASSERT(res.second);
  new_nick->add_channel(channel);
  return new_nick;
#endif
}

boost::shared_ptr< Nick > Target::get_joined_nick	(	Identity &	identity,
		std::string const &	nick_name,
		boost::shared_ptr< Channel > &	channel
	)			[static]

Return a shared pointer to the Nick object with name nick_name that is joined to channel channel.

Definition at line 54 of file Target.cc.

References ASSERT, DoutEntering, is_nick(), Network::is_private(), Identity::key(), ServerConnection::network(), network(), Identity::server_connection(), and THROW_EXCEPTION.

Referenced by Identity::new_server_message_received(), and Channel::new_server_message_received().

{
#if 0
  ASSERT(!debug::secondary_connection);
  DoutEntering(dc::debug, "Target::get_joined_nick(" << identity << ", \"" << nick_name << "\", \"" << channel->serverside_name() << "\")");
  ASSERT(is_nick(nick_name));

  // Get the network.
  Network& network(identity.server_connection().network());
  ASSERT(!network.is_private());

  Channel::members_type::iterator iter = channel->members().find(nick_name);
  if (iter == channel->members().end())
    THROW_EXCEPTION(unknown_target(), "The identity " << identity.key() << " has no server side joined nick \"" << nick_name << "\" on channel " << channel);

  return iter->second.get_nick();
#endif
}

virtual void Target::new_client_message_received

(

ClientMessageIn const &

)

[pure virtual]

This is called when a new message targetted at this target is received.

Implemented in Channel, Nick, NoticeTarget, PrivateTarget, and QuestionTarget.

virtual void Target::new_server_message_received

(

ServerMessageIn const &

)

[pure virtual]

This is called when a new message targetted at this target is received.

Implemented in Channel, Nick, and PrivateTarget.

---

Member Data Documentation

Network* Target::M_network [protected]

The underlying network.

Definition at line 42 of file Target.h.

Referenced by network(), Nick::serverside_nick_changed_to(), Nick::set_network(), and ~Target().

---

The documentation for this class was generated from the following files:

• Target.h
• Target.cc