ircproxy  The Ultimate Cyborg

---

Channel.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file Channel.h
//! @brief This file contains the declaration of class Channel.
//
// 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 CHANNEL_H
#define CHANNEL_H

#ifndef USE_PCH
#include "debug.h"
#include <map>
#include <boost/noncopyable.hpp>
#endif

#include "Target.h"
#include "IdentityReference.h"
#include "Member.h"
#include "Network.h"

class MessageIn;

/*! @brief An IRC Channel.
 *
 */
class Channel : public Target, public IdentityReference, public boost::noncopyable {
public:
  //! The type returned by members().
  typedef std::map<std::string, Member> members_type;

private:
  members_type M_members;       //!< The members on this channel.
  bool M_received_names;        //!< True if we received the NAMES reply after joining.
  time_t M_creation_time;       //!< The time as received from numeric 329, or 0 if nothing was received (yet).
  std::string M_key;            //!< Last known channel key, if any.

private:
  // This is the only function that is allowed to create non-private Channel objects.
  friend boost::shared_ptr<Channel> Target::add_channel(Identity& identity, std::string const& channel_name);
  //! Construct a Channel instance for identity \a identity with name \a target_name on network \a network.
  Channel(Identity& identity, std::string const& target_name, Network& network) :
      Target(&network), IdentityReference(&identity),
      M_received_names(false), M_creation_time(0)
      {
        ASSERT(!network.is_private());
        Dout(dc::objects, "Constructing Channel(" << identity << ", \"" << target_name << "\", " << network << ") " << static_cast<IdentityReference&>(*this));
      }
public:
  //! Construct a Channel instance for identity \a identity with name \a target_name on private network \a private_network.
  Channel(Identity& identity, std::string const& target_name, Network& private_network, int) :
      Target(&private_network), IdentityReference(&identity),
      M_received_names(true), M_creation_time(0)
      {
        ASSERT(private_network.is_private());
        Dout(dc::objects, "Constructing private Channel(" << identity << ", \"" << target_name << "\", " << private_network << ") " <<
            static_cast<IdentityReference&>(*this));
      }
#ifdef CWDEBUG
  //! Destructor.
  ~Channel() { Dout(dc::objects, "Destructing Channel " << *this); }
#endif
  virtual void new_client_message_received(ClientMessageIn const& msg);
  virtual void new_server_message_received(ServerMessageIn const& msg);

  virtual std::string in_name(ClientSession const&) const { return "FIXME"; }
  virtual std::string in_name(ServerSession const&) const { return "FIXME"; }
  virtual std::string out_name(ClientSession const&) const { return "FIXME"; }
  virtual std::string out_name(ServerSession const&) const { return "FIXME"; }

  //! Accessor to the members map.
  members_type& members(void) { return M_members; }
  //! Accessor to the members map.
  members_type const& members(void) const { return M_members; }

  void sub_joined_nick(boost::shared_ptr<Nick> nick);

  //! This is called when the first end of NAMES (numeric 366) is being received.
  void set_received_names(void) { M_received_names = true; }

  //! This is called when a channel is rejoined after a reconnect.
  void reset_received_names(void) { M_received_names = false; }

  //! This is called when numeric 329 is being received.
  void set_creation_time(time_t creation_time) { M_creation_time = creation_time; }

  //! Return true if the first end of NAMES (numeric 366) has been received.
  bool received_names(void) const { return M_received_names; }

  //! Return the creation time of the channel, or 0 when not known.
  time_t creation_time(void) const { return M_creation_time; }

  //! Returns true if Channel::key is valid.
  bool has_key(void) const { return !M_key.empty(); }

  //! Returns the last channel key that was seen.
  std::string const& key(void) const { return M_key; }
};

#endif // CHANNEL_H

---