As preparation for revamping the whole networking stuff, I did two renames:

[quassel.git] / src / common / network.cpp

diff --git a/src/common/networkinfo.cpp b/src/common/network.cpp
similarity index 73%
rename from src/common/networkinfo.cpp
rename to src/common/network.cpp
index 19f4233..780a5d8 100644 (file)
--- a/src/common/networkinfo.cpp
+++ b/src/common/network.cpp
@@ -17,7 +17,7 @@
  *   Free Software Foundation, Inc.,                                       *
  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  ***************************************************************************/
-#include "networkinfo.h"
+#include "network.h"
 
 #include "signalproxy.h"
 #include "ircuser.h"
@@ -31,7 +31,7 @@
 // ====================
 //  Public:
 // ====================
-NetworkInfo::NetworkInfo(const uint &networkid, QObject *parent)
+Network::Network(const uint &networkid, QObject *parent)
   : SyncableObject(parent),
     _networkId(networkid),
     _initialized(false),
@@ -48,7 +48,7 @@ NetworkInfo::NetworkInfo(const uint &networkid, QObject *parent)
 }
 
 // I think this is unnecessary since IrcUsers have us as their daddy :)
-//NetworkInfo::~NetworkInfo() {
+//Network::~Network() {
 //   QHashIterator<QString, IrcUser *> ircuser(_ircUsers);
 //   while (ircuser.hasNext()) {
 //     ircuser.next();
@@ -56,32 +56,32 @@ NetworkInfo::NetworkInfo(const uint &networkid, QObject *parent)
 //   }
 //}
 
-uint NetworkInfo::networkId() const {
+uint Network::networkId() const {
   return _networkId;
 }
 
-bool NetworkInfo::initialized() const {
+bool Network::initialized() const {
   return _initialized;
 }
 
-SignalProxy *NetworkInfo::proxy() const {
+SignalProxy *Network::proxy() const {
   return _proxy;
 }
 
-void NetworkInfo::setProxy(SignalProxy *proxy) {
+void Network::setProxy(SignalProxy *proxy) {
   _proxy = proxy;
   proxy->synchronize(this);
 }
 
-bool NetworkInfo::isMyNick(const QString &nick) const {
+bool Network::isMyNick(const QString &nick) const {
   return (myNick().toLower() == nick.toLower());
 }
 
-bool NetworkInfo::isMyNick(IrcUser *ircuser) const {
+bool Network::isMyNick(IrcUser *ircuser) const {
   return (ircuser->nick().toLower() == myNick().toLower());
 }
 
-bool NetworkInfo::isChannelName(const QString &channelname) const {
+bool Network::isChannelName(const QString &channelname) const {
   if(channelname.isEmpty())
     return false;
   
@@ -91,41 +91,41 @@ bool NetworkInfo::isChannelName(const QString &channelname) const {
     return QString("#&!+").contains(channelname[0]);
 }
 
-QString NetworkInfo::prefixToMode(const QString &prefix) {
+QString Network::prefixToMode(const QString &prefix) {
   if(prefixes().contains(prefix))
     return QString(prefixModes()[prefixes().indexOf(prefix)]);
   else
     return QString();
 }
 
-QString NetworkInfo::prefixToMode(const QCharRef &prefix) {
+QString Network::prefixToMode(const QCharRef &prefix) {
   return prefixToMode(QString(prefix));
 }
 
-QString NetworkInfo::modeToPrefix(const QString &mode) {
+QString Network::modeToPrefix(const QString &mode) {
   if(prefixModes().contains(mode))
     return QString(prefixes()[prefixModes().indexOf(mode)]);
   else
     return QString();
 }
 
-QString NetworkInfo::modeToPrefix(const QCharRef &mode) {
+QString Network::modeToPrefix(const QCharRef &mode) {
   return modeToPrefix(QString(mode));
 }
   
-QString NetworkInfo::networkName() const {
+QString Network::networkName() const {
   return _networkName;
 }
 
-QString NetworkInfo::currentServer() const {
+QString Network::currentServer() const {
   return _currentServer;
 }
 
-QString NetworkInfo::myNick() const {
+QString Network::myNick() const {
   return _myNick;
 }
 
-QStringList NetworkInfo::nicks() const {
+QStringList Network::nicks() const {
   // we don't use _ircUsers.keys() since the keys may be
   // not up to date after a nick change
   QStringList nicks;
@@ -135,29 +135,29 @@ QStringList NetworkInfo::nicks() const {
   return nicks;
 }
 
-QStringList NetworkInfo::channels() const {
+QStringList Network::channels() const {
   return _ircChannels.keys();
 }
 
-QString NetworkInfo::prefixes() {
+QString Network::prefixes() {
   if(_prefixes.isNull())
     determinePrefixes();
   
   return _prefixes;
 }
 
-QString NetworkInfo::prefixModes() {
+QString Network::prefixModes() {
   if(_prefixModes.isNull())
     determinePrefixes();
 
   return _prefixModes;
 }
 
-bool NetworkInfo::supports(const QString &param) const {
+bool Network::supports(const QString &param) const {
   return _supports.contains(param);
 }
 
-QString NetworkInfo::support(const QString &param) const {
+QString Network::support(const QString &param) const {
   QString support_ = param.toUpper();
   if(_supports.contains(support_))
     return _supports[support_];
@@ -165,7 +165,7 @@ QString NetworkInfo::support(const QString &param) const {
     return QString();
 }
 
-IrcUser *NetworkInfo::newIrcUser(const QString &hostmask) {
+IrcUser *Network::newIrcUser(const QString &hostmask) {
   QString nick(nickFromMask(hostmask).toLower());
   if(!_ircUsers.contains(nick)) {
     IrcUser *ircuser = new IrcUser(hostmask, this);
@@ -175,7 +175,7 @@ IrcUser *NetworkInfo::newIrcUser(const QString &hostmask) {
     if(proxy())
       proxy()->synchronize(ircuser);
     else
-      qWarning() << "unable to synchronize new IrcUser" << hostmask << "forgot to call NetworkInfo::setProxy(SignalProxy *)?";
+      qWarning() << "unable to synchronize new IrcUser" << hostmask << "forgot to call Network::setProxy(SignalProxy *)?";
     
     connect(ircuser, SIGNAL(nickSet(QString)), this, SLOT(ircUserNickChanged(QString)));
     connect(ircuser, SIGNAL(initDone()), this, SIGNAL(ircUserInitDone()));
@@ -186,11 +186,11 @@ IrcUser *NetworkInfo::newIrcUser(const QString &hostmask) {
   return _ircUsers[nick];
 }
 
-IrcUser *NetworkInfo::newIrcUser(const QByteArray &hostmask) {
+IrcUser *Network::newIrcUser(const QByteArray &hostmask) {
   return newIrcUser(decodeString(hostmask));
 }
 
-void NetworkInfo::removeIrcUser(IrcUser *ircuser) {
+void Network::removeIrcUser(IrcUser *ircuser) {
   QString nick = _ircUsers.key(ircuser);
   if(nick.isNull())
     return;
@@ -200,13 +200,13 @@ void NetworkInfo::removeIrcUser(IrcUser *ircuser) {
   emit ircUserRemoved(nick);
 }
 
-void NetworkInfo::removeIrcUser(QString nick) {
+void Network::removeIrcUser(QString nick) {
   IrcUser *ircuser;
   if((ircuser = ircUser(nick)) != 0)
     removeIrcUser(ircuser);
 }
 
-IrcUser *NetworkInfo::ircUser(QString nickname) const {
+IrcUser *Network::ircUser(QString nickname) const {
   nickname = nickname.toLower();
   if(_ircUsers.contains(nickname))
     return _ircUsers[nickname];
@@ -214,15 +214,15 @@ IrcUser *NetworkInfo::ircUser(QString nickname) const {
     return 0;
 }
 
-IrcUser *NetworkInfo::ircUser(const QByteArray &nickname) const {
+IrcUser *Network::ircUser(const QByteArray &nickname) const {
   return ircUser(decodeString(nickname));
 }
 
-QList<IrcUser *> NetworkInfo::ircUsers() const {
+QList<IrcUser *> Network::ircUsers() const {
   return _ircUsers.values();
 }
 
-IrcChannel *NetworkInfo::newIrcChannel(const QString &channelname) {
+IrcChannel *Network::newIrcChannel(const QString &channelname) {
   if(!_ircChannels.contains(channelname.toLower())) {
     IrcChannel *channel = new IrcChannel(channelname, this);
     // mark IrcUser as already initialized to keep the SignalProxy from requesting initData
@@ -232,7 +232,7 @@ IrcChannel *NetworkInfo::newIrcChannel(const QString &channelname) {
     if(proxy())
       proxy()->synchronize(channel);
     else
-      qWarning() << "unable to synchronize new IrcChannel" << channelname << "forgot to call NetworkInfo::setProxy(SignalProxy *)?";
+      qWarning() << "unable to synchronize new IrcChannel" << channelname << "forgot to call Network::setProxy(SignalProxy *)?";
 
     connect(channel, SIGNAL(initDone()), this, SIGNAL(ircChannelInitDone()));
     connect(channel, SIGNAL(destroyed()), this, SLOT(channelDestroyed()));
@@ -242,11 +242,11 @@ IrcChannel *NetworkInfo::newIrcChannel(const QString &channelname) {
   return _ircChannels[channelname.toLower()];
 }
 
-IrcChannel *NetworkInfo::newIrcChannel(const QByteArray &channelname) {
+IrcChannel *Network::newIrcChannel(const QByteArray &channelname) {
   return newIrcChannel(decodeString(channelname));
 }
 
-IrcChannel *NetworkInfo::ircChannel(QString channelname) {
+IrcChannel *Network::ircChannel(QString channelname) {
   channelname = channelname.toLower();
   if(_ircChannels.contains(channelname))
     return _ircChannels[channelname];
@@ -254,44 +254,44 @@ IrcChannel *NetworkInfo::ircChannel(QString channelname) {
     return 0;
 }
 
-IrcChannel *NetworkInfo::ircChannel(const QByteArray &channelname) {
+IrcChannel *Network::ircChannel(const QByteArray &channelname) {
   return ircChannel(decodeString(channelname));
 }
 
 
-QList<IrcChannel *> NetworkInfo::ircChannels() const {
+QList<IrcChannel *> Network::ircChannels() const {
   return _ircChannels.values();
 }
 
-QTextCodec *NetworkInfo::codecForEncoding() const {
+QTextCodec *Network::codecForEncoding() const {
   return _codecForEncoding;
 }
 
-void NetworkInfo::setCodecForEncoding(const QString &name) {
+void Network::setCodecForEncoding(const QString &name) {
   setCodecForEncoding(QTextCodec::codecForName(name.toAscii()));
 }
 
-void NetworkInfo::setCodecForEncoding(QTextCodec *codec) {
+void Network::setCodecForEncoding(QTextCodec *codec) {
   _codecForEncoding = codec;
 }
 
-QTextCodec *NetworkInfo::codecForDecoding() const {
+QTextCodec *Network::codecForDecoding() const {
   return _codecForDecoding;
 }
 
-void NetworkInfo::setCodecForDecoding(const QString &name) {
+void Network::setCodecForDecoding(const QString &name) {
   setCodecForDecoding(QTextCodec::codecForName(name.toAscii()));
 }
 
-void NetworkInfo::setCodecForDecoding(QTextCodec *codec) {
+void Network::setCodecForDecoding(QTextCodec *codec) {
   _codecForDecoding = codec;
 }
 
-QString NetworkInfo::decodeString(const QByteArray &text) const {
+QString Network::decodeString(const QByteArray &text) const {
   return ::decodeString(text, _codecForDecoding);
 }
 
-QByteArray NetworkInfo::encodeString(const QString string) const {
+QByteArray Network::encodeString(const QString string) const {
   if(_codecForEncoding) {
     return _codecForEncoding->fromUnicode(string);
   }
@@ -301,36 +301,36 @@ QByteArray NetworkInfo::encodeString(const QString string) const {
 // ====================
 //  Public Slots:
 // ====================
-void NetworkInfo::setNetworkName(const QString &networkName) {
+void Network::setNetworkName(const QString &networkName) {
   _networkName = networkName;
   emit networkNameSet(networkName);
 }
 
-void NetworkInfo::setCurrentServer(const QString &currentServer) {
+void Network::setCurrentServer(const QString &currentServer) {
   _currentServer = currentServer;
   emit currentServerSet(currentServer);
 }
 
-void NetworkInfo::setMyNick(const QString &nickname) {
+void Network::setMyNick(const QString &nickname) {
   _myNick = nickname;
   emit myNickSet(nickname);
 }
 
-void NetworkInfo::addSupport(const QString &param, const QString &value) {
+void Network::addSupport(const QString &param, const QString &value) {
   if(!_supports.contains(param)) {
     _supports[param] = value;
     emit supportAdded(param, value);
   }
 }
 
-void NetworkInfo::removeSupport(const QString &param) {
+void Network::removeSupport(const QString &param) {
   if(_supports.contains(param)) {
     _supports.remove(param);
     emit supportRemoved(param);
   }
 }
 
-QVariantMap NetworkInfo::initSupports() const {
+QVariantMap Network::initSupports() const {
   QVariantMap supports;
   QHashIterator<QString, QString> iter(_supports);
   while(iter.hasNext()) {
@@ -340,7 +340,7 @@ QVariantMap NetworkInfo::initSupports() const {
   return supports;
 }
 
-QStringList NetworkInfo::initIrcUsers() const {
+QStringList Network::initIrcUsers() const {
   QStringList hostmasks;
   foreach(IrcUser *ircuser, ircUsers()) {
     hostmasks << ircuser->hostmask();
@@ -348,11 +348,11 @@ QStringList NetworkInfo::initIrcUsers() const {
   return hostmasks;
 }
 
-QStringList NetworkInfo::initIrcChannels() const {
+QStringList Network::initIrcChannels() const {
   return _ircChannels.keys();
 }
 
-void NetworkInfo::initSetSupports(const QVariantMap &supports) {
+void Network::initSetSupports(const QVariantMap &supports) {
   QMapIterator<QString, QVariant> iter(supports);
   while(iter.hasNext()) {
     iter.next();
@@ -360,7 +360,7 @@ void NetworkInfo::initSetSupports(const QVariantMap &supports) {
   }
 }
 
-void NetworkInfo::initSetIrcUsers(const QStringList &hostmasks) {
+void Network::initSetIrcUsers(const QStringList &hostmasks) {
   if(!_ircUsers.empty())
     return;
   foreach(QString hostmask, hostmasks) {
@@ -368,14 +368,14 @@ void NetworkInfo::initSetIrcUsers(const QStringList &hostmasks) {
   }
 }
 
-void NetworkInfo::initSetChannels(const QStringList &channels) {
+void Network::initSetChannels(const QStringList &channels) {
   if(!_ircChannels.empty())
     return;
   foreach(QString channel, channels)
     newIrcChannel(channel);
 }
 
-IrcUser *NetworkInfo::updateNickFromMask(const QString &mask) {
+IrcUser *Network::updateNickFromMask(const QString &mask) {
   QString nick(nickFromMask(mask).toLower());
   IrcUser *ircuser;
   
@@ -388,7 +388,7 @@ IrcUser *NetworkInfo::updateNickFromMask(const QString &mask) {
   return ircuser;
 }
 
-void NetworkInfo::ircUserNickChanged(QString newnick) {
+void Network::ircUserNickChanged(QString newnick) {
   QString oldnick = _ircUsers.key(qobject_cast<IrcUser*>(sender()));
 
   if(oldnick.isNull())
@@ -400,19 +400,19 @@ void NetworkInfo::ircUserNickChanged(QString newnick) {
     setMyNick(newnick);
 }
 
-void NetworkInfo::ircUserDestroyed() {
+void Network::ircUserDestroyed() {
   IrcUser *ircuser = static_cast<IrcUser *>(sender());
   Q_ASSERT(ircuser);
   removeIrcUser(ircuser);
 }
 
-void NetworkInfo::channelDestroyed() {
+void Network::channelDestroyed() {
   IrcChannel *channel = static_cast<IrcChannel *>(sender());
   Q_ASSERT(channel);
   _ircChannels.remove(_ircChannels.key(channel));
 }
 
-void NetworkInfo::setInitialized() {
+void Network::setInitialized() {
   _initialized = true;
   emit initDone();
 }
@@ -420,7 +420,7 @@ void NetworkInfo::setInitialized() {
 // ====================
 //  Private:
 // ====================
-void NetworkInfo::determinePrefixes() {
+void Network::determinePrefixes() {
   // seems like we have to construct them first
   QString PREFIX = support("PREFIX");