KviIrcServer.h

Go to the documentation of this file.

#ifndef _KVI_IRCSERVER_H_
#define _KVI_IRCSERVER_H_

//=============================================================================
//
//   File : KviIrcServer.h
//   Creation date : Mon Jul 10 2000 03:24:11 by Szymon Stefanek
//
//   This file is part of the KVIrc IRC client distribution
//   Copyright (C) 2000-2010 Szymon Stefanek (pragma at kvirc dot net)
//
//   This program is FREE software. You can redistribute it and/or
//   modify it under the terms of the GNU General Public License
//   as published by the Free Software Foundation; either version 2
//   of the License, or (at your option) any later version.
//
//   This program is distributed in the HOPE that it will be USEFUL,
//   but WITHOUT ANY WARRANTY; without even the implied warranty of
//   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
//   See the GNU General Public License for more details.
//
//   You should have received a copy of the GNU General Public License
//   along with this program. If not, write to the Free Software Foundation,
//   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//=============================================================================

#include "kvi_settings.h"
#include "KviHeapObject.h"
#include "KviQString.h"
#include "KviPointerList.h"

#include <QStringList>

class KviConfigurationFile;
class KviNickServRuleSet;
class KviProxy;
class KviProxyDataBase;
class KviIrcServerReconnectInfo;

class KVILIB_API KviIrcServer : public KviHeapObject
{
public:
        enum Flags
        {
                IPv6 = 1,     
                CacheIP = 2,  
                SSL = 4,      
                STARTTLS = 8, 
                SASL = 16,    
                CAP = 32,     
                FAVORITE = 64 
        };

        KviIrcServer();

        KviIrcServer(const KviIrcServer & serv);

        ~KviIrcServer();

private:
        KviIrcServerReconnectInfo * m_pReconnectInfo;
        QString m_szHostname;        
        QString m_szIp;              
        QString m_szDescription;     
        kvi_u32_t m_uPort;           
        unsigned short int m_uFlags; 
        // Extended data
        QString m_szUserIdentityId;           
        QString m_szUser;                     
        QString m_szPass;                     
        QString m_szNick;                     
        QString m_szAlternativeNick;          
        QString m_szRealName;                 
        QString m_szInitUMode;                
        QString m_szOnConnectCommand;         
        QString m_szOnLoginCommand;           
        QString m_szLinkFilter;               
        QString m_szEncoding;                 
        QString m_szTextEncoding;             
        QStringList * m_pAutoJoinChannelList; 
        bool m_bAutoConnect;                  
        QString m_szId;                       
        int m_iProxy;                         
        QString m_szSaslNick;                 
        QString m_szSaslPass;                 
public:
        KviIrcServerReconnectInfo * reconnectInfo()
        {
                return m_pReconnectInfo;
        }

        void clearReconnectInfo();

        void setReconnectInfo(KviIrcServerReconnectInfo * pInfo);

        inline int proxy() { return m_iProxy; };

        KviProxy * proxyServer(KviProxyDataBase * pDb);

        inline kvi_u32_t port() const { return m_uPort; };

        inline const QString & password() const { return m_szPass; };

        inline const QString & saslNick() const { return m_szSaslNick; };

        inline const QString & saslPass() const { return m_szSaslPass; };

        inline const QString & nickName() const { return m_szNick; };

        inline const QString & alternativeNickName() const { return m_szAlternativeNick; };

        inline const QString & initUMode() const { return m_szInitUMode; };

        inline const QString & hostName() const { return m_szHostname; };

        inline const QString & ip() const { return m_szIp; };

        inline const QString & onLoginCommand() const { return m_szOnLoginCommand; };

        inline const QString & onConnectCommand() const { return m_szOnConnectCommand; };

        inline const QString & userName() const { return m_szUser; };

        inline const QString & realName() const { return m_szRealName; };

        inline const QString & linkFilter() const { return m_szLinkFilter; };

        inline const QString & description() const { return m_szDescription; };

        inline const QString & encoding() const { return m_szEncoding; };

        inline const QString & textEncoding() const { return m_szTextEncoding; };

        inline const QString & id() const { return m_szId; };

        inline const QString & userIdentityId() const { return m_szUserIdentityId; };

        inline bool autoConnect() const { return m_bAutoConnect; };

        inline QStringList * autoJoinChannelList() { return m_pAutoJoinChannelList; };

        inline const QString autoJoinChannelListAsString() { return m_pAutoJoinChannelList ? m_pAutoJoinChannelList->join(",") : ""; };

        inline bool isIPv6() const { return (m_uFlags & KviIrcServer::IPv6); };

        inline bool useSSL() const { return (m_uFlags & KviIrcServer::SSL); };

        inline bool enabledCAP() const { return (m_uFlags & KviIrcServer::CAP); };

        inline bool enabledSTARTTLS() const { return (m_uFlags & KviIrcServer::STARTTLS); };

        inline bool enabledSASL() const { return (m_uFlags & KviIrcServer::SASL); };

        inline bool cacheIp() const { return (m_uFlags & KviIrcServer::CacheIP); };

        QString ircUri();

        inline void setProxy(int iProxy) { m_iProxy = iProxy; };

        inline void setIp(const QString & szIp) { m_szIp = szIp; };

        inline void setPort(kvi_u32_t uPort) { m_uPort = uPort; };

        inline void setHostName(const QString & szHost) { m_szHostname = szHost; };

        inline void setDescription(const QString & szDesc) { m_szDescription = szDesc; };

        inline void setUserName(const QString & szUser) { m_szUser = szUser; };

        inline void setPassword(const QString & szPass) { m_szPass = szPass; };

        inline void setNickName(const QString & szNick) { m_szNick = szNick; };

        inline void setAlternativeNickName(const QString & szNick) { m_szAlternativeNick = szNick; };

        inline void setSaslPass(const QString & szPass) { m_szSaslPass = szPass; };

        inline void setSaslNick(const QString & szNick) { m_szSaslNick = szNick; };

        inline void setRealName(const QString & szReal) { m_szRealName = szReal; };

        inline void setEncoding(const QString & szEncoding) { m_szEncoding = szEncoding; };

        inline void setTextEncoding(const QString & szEncoding) { m_szTextEncoding = szEncoding; };

        inline void setInitUMode(const QString & szUMode) { m_szInitUMode = szUMode; };

        inline void setOnConnectCommand(const QString & szCmd) { m_szOnConnectCommand = szCmd; };

        inline void setOnLoginCommand(const QString & szCmd) { m_szOnLoginCommand = szCmd; };

        inline void setLinkFilter(const QString & szFilter) { m_szLinkFilter = szFilter; };

        void setAutoJoinChannelList(QStringList * pNewChannelList);

        void setAutoJoinChannelList(const QString & szNewChannelList);

        inline void setAutoConnect(bool bAutoConnect) { m_bAutoConnect = bAutoConnect; };

        inline void setUserIdentityId(const QString & szUserIdentityId) { m_szUserIdentityId = szUserIdentityId; };

        inline void setIPv6(bool bSet)
        {
                if(bSet)
                        m_uFlags |= KviIrcServer::IPv6;
                else
                        m_uFlags &= static_cast<unsigned short>(~KviIrcServer::IPv6);
        };

        inline void setUseSSL(bool bSet)
        {
                if(bSet)
                        m_uFlags |= KviIrcServer::SSL;
                else
                        m_uFlags &= static_cast<unsigned short>(~KviIrcServer::SSL);
        };

        inline void setEnabledSTARTTLS(bool bSet)
        {
                if(bSet)
                        m_uFlags |= KviIrcServer::STARTTLS;
                else
                        m_uFlags &= static_cast<unsigned short>(~KviIrcServer::STARTTLS);
        };

        inline void setEnabledCAP(bool bSet)
        {
                if(bSet)
                        m_uFlags |= KviIrcServer::CAP;
                else
                        m_uFlags &= static_cast<unsigned short>(~KviIrcServer::CAP);
        };

        inline void setEnabledSASL(bool bSet)
        {
                if(bSet)
                        m_uFlags |= KviIrcServer::SASL;
                else
                        m_uFlags &= static_cast<unsigned short>(~KviIrcServer::SASL);
        };

        inline void setCacheIp(bool bSet)
        {
                if(bSet)
                        m_uFlags |= KviIrcServer::CacheIP;
                else
                        m_uFlags &= static_cast<unsigned short>(~KviIrcServer::CacheIP);
        };

        void generateUniqueId();

        inline void setId(const QString & szId)
        {
                m_szId = szId;
                if(m_szId.isEmpty())
                        generateUniqueId();
        };

        bool load(KviConfigurationFile * pCfg, const QString & szPrefix);

        void save(KviConfigurationFile * pCfg, const QString & szPrefix);

        void operator=(const KviIrcServer & serv);

        inline void setFavorite(bool bSet)
        {
                if(bSet)
                        m_uFlags |= KviIrcServer::FAVORITE;
                else
                        m_uFlags &= static_cast<unsigned short>(~KviIrcServer::FAVORITE);
        };

        inline bool favorite() const { return (m_uFlags & KviIrcServer::FAVORITE); };
};

#endif //_KVI_IRCSERVER_H_