ircproxy  The Ultimate Cyborg

---

Network.h

Go to the documentation of this file.

// ircproxy -- An intelligent IRC proxy
//
//! @file Network.h
//! @brief Header of class Network
//
// Copyright (C) 2005, 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 NETWORK_H
#define NETWORK_H

#ifndef USE_PCH
#include <string>
#include <vector>
#include <cassert>
#include <boost/shared_ptr.hpp>
#endif

#include "Server.h"
#include "Target.h"

class PersistXML;

/*! @brief An IRC network.
 *
 * This class represents an IRC network.
 * Servers that are part of a network can be added manually
 * or might have been seen by the IRC proxy while connected
 * to this network. The list of servers is therefore not
 * necessarily up to date.
 */
class Network {
public:
  typedef std::vector<boost::shared_ptr<Server> > servers_type; //!< The type of Network::M_servers.

private:
  std::string                   M_name;         //!< Human readable name of network.
  std::string                   M_domain;       //!< Common domain of servers, if any. Empty otherwise.
  servers_type                  M_servers;      //!< List of all known servers that belong to this network.
  target_lookup_map_type        M_targets;      //!< Map with all known targets, related to at least one existing Identity. Only valid when M_private is false.
  bool                          M_private;      //!< True if this is a private network (owned by Identity).

public:
  //! Construct an uninitialized object. It will be initialized by Network::serialize.
  Network(void) : M_private(false)              // Private networks are not serialized.
      { Dout(dc::objects, "Constructing Network()"); }

  //! Construct a Network object with name \c name, without common domain.
  Network(std::string const& name, bool priv = false) : M_name(name), M_private(priv)
      { Dout(dc::objects, "Constructing Network(\"" << name << "\", " << priv << ")"); }

  //! Construct a Network object with name \c name and common domain \c domain.
  Network(std::string const& name, std::string const& domain, bool priv = false) :
      M_name(name), M_domain(domain), M_private(priv)
      { Dout(dc::objects, "Constructing Network(\"" << name << "\", \"" << domain << "\", " << priv << ")"); }

#ifdef CDWDEBUG
  //! Destruct this Network object.
  ~Network() { Dout(dc::objects, "Destructing Network " << *this); }

  //! Copy constructor.
  Network(Network const& network) :
      M_name(network.M_name),
      M_domain(network.M_domain),
      M_servers(network.M_servers),
      M_targets(network.M_targets),
      M_private(network.M_private)
      { Dout(dc::objects, "Copy-constructing Network from " << network); }
#endif

  //! Human readable name of this network.
  std::string const& name(void) const { return M_name; }

  //! True iff this Network object has a common domain name set.
  bool has_domain(void) const { return !M_domain.empty(); }

  //! The common domain name of this network. May only be called when Network::has_domain returns true.
  std::string const& domain(void) const { assert(has_domain()); return M_domain; }

  //! A const reference to the list of servers associated with this network.
  servers_type const& servers(void) const { return M_servers; }

  //! A reference to the list of servers associated with this network.
  servers_type& servers(void) { return M_servers; }

  //! A const reference to an STL container with all known targets.
  target_lookup_map_type const& targets(void) const { ASSERT(!M_private); return M_targets; }

  //! A reference to an STL container with all known targets.
  target_lookup_map_type& targets(void) { ASSERT(!M_private); return M_targets; }

  //! Returns true if this is a private network, owned by an Identity.
  bool is_private(void) const { return M_private; }

  // The following seems out of place here, but it's part of the
  // network due to dynamic nature of numeric 005.

  //!< The type of the WHO flags mask.
  typedef uint32_t who_flags_type;
  //! A pair matching a WHO flag with it's mask bit.
  struct WhoMap { char who_flag; who_flags_type mask; };
  //! A vector mapping WHO flag characters with their mask bit.
  typedef std::vector<WhoMap> who_flag_vector_type;

private:
  who_flag_vector_type M_who_flag_vector;       //!< Vector with mapping between WHO flags and corresponding mask bits.

public:
  //! Initialize M_who_flag_vector, called when numeric 005 is received.
  void init_who_flag_table(std::string const& umodes, std::string prefix);

  //! Translate a mask bit to it's WHO flag character.
  char flag_to_char(who_flags_type maskbit) const;

  //! Translate a WHO flag character to it's mask bit.
  who_flags_type char_to_flag(char who_flag) const;

  void serialize(PersistXML& xml);
};

#endif // NETWORK_H

---