ircresponsetype.cpp

//------------------------------------------------------------------------------
// ircresponsetype.cpp
//------------------------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301  USA
//
//------------------------------------------------------------------------------
// Copyright (C) 2011 "Zalewa" <zalewapl@gmail.com>
//------------------------------------------------------------------------------
#include "ircresponsetype.h"

IRCResponseType::IRCResponseType()
{
        d.type = Invalid;
        d.numericType = -1;
}

IRCResponseType::IRCResponseType(MsgType type)
{
        d.type = type;
        d.numericType = toRfcNumber(type);
}

IRCResponseType::IRCResponseType(const QString& type)
{
        d.type = typeFromRfcString(type);

        // Get numeric type from string.
        bool bOk = false;
        int numericType = type.toInt(&bOk);
        if (!bOk)
        {
                numericType = -1;
        }
        d.numericType = numericType;
}

IRCResponseType IRCResponseType::fromIntegerResponseValue(int responseType)
{
        // Response type is always a 3-digit number. Conver the passed integer with
        // leading zeros if necessary and then pass it to typeFromRfcString().

        // The result here is d.numericType always set to responseType, and the
        // d.type set to either Invalid or appropriate value if the number was
        // recognized.
        QString strResponseType = QString("%1").arg(responseType, 3, 10, QChar('0'));

        IRCResponseType newIRCResponseType;
        newIRCResponseType.d.type = typeFromRfcString(strResponseType);
        newIRCResponseType.d.numericType = responseType;

        return newIRCResponseType;
}

bool IRCResponseType::operator==(const IRCResponseType& other) const
{
        return d.type == other.d.type;
}

bool IRCResponseType::operator!=(const IRCResponseType& other) const
{
        return !((*this) == other);
}

int IRCResponseType::toRfcNumber(MsgType type)
{
        if (type == Invalid)
        {
                return -1;
        }

        QString str = toRfcString(type);

        bool bOk = false;
        int val = str.toInt(&bOk);

        return bOk ? val : -1;
}

QString IRCResponseType::toRfcString(MsgType type)
{
        switch (type)
        {
                case HelloClient:
                        return "001";

                case RPLISupport:
                        return "005";

                case RPLLUserClient:
                        return "251";

                case RPLLUserOp:
                        return "252";

                case RPLLUserUnknown:
                        return "253";

                case RPLLUserChannels:
                        return "254";

                case RPLLUserMe:
                        return "255";

                case RPLAway:
                        return "301";

                case RPLWhoIsRegnick:
                        return "307";

                case RPLWhoIsUser:
                        return "311";

                case RPLWhoIsServer:
                        return "312";

                case RPLWhoIsOperator:
                        return "313";

                case RPLWhoIsIdle:
                        return "317";

                case RPLEndOfWhoIs:
                        return "318";

                case RPLWhoIsChannels:
                        return "319";

                case RPLWhoIsSpecial:
                        return "320";

                case RPLChannelUrl:
                        return "328";

                case RPLCreationTime:
                        return "329";

                case RPLWhoIsAccount:
                        return "330";

                case RPLTopic:
                        return "332";

                case RPLTopicWhoTime:
                        return "333";

                case RPLWhoIsBot:
                        return "335";

                case RPLWhoIsActually:
                        return "338";

                case RPLNamReply:
                        return "353";

                case RPLEndOfNames:
                        return "366";

                case RPLMOTD:
                        return "372";

                case RPLMOTDStart:
                        return "375";

                case RPLEndOfMOTD:
                        return "376";

                case RPLWhoIsHost:
                        return "378";

                case RPLWhoIsModes:
                        return "379";

                case ERRNoSuchNick:
                        return "401";

                case ERRCannotSendToChan:
                        return "404";

                case ERRErroneousNickname:
                        return "432";

                case ERRNicknameInUse:
                        return "433";

                case ERRChannelIsFull:
                        return "471";

                case ERRInviteOnlyChan:
                        return "473";

                case ERRBannedFromChan:
                        return "474";

                case ERRBadChannelKey:
                        return "475";

                case ERRBadChannelMask:
                        return "476";

                case ERRNoChanModes:
                        return "477";

                case ERRChanOpPrivIsNeeded:
                        return "482";

                case RPLWhoIsSecure:
                        return "671";

                case Join:
                        return "JOIN";

                case Kick:
                        return "KICK";

                case Kill:
                        return "KILL";

                case Mode:
                        return "MODE";

                case Nick:
                        return "NICK";

                case Notice:
                        return "NOTICE";

                case Part:
                        return "PART";

                case Ping:
                        return "PING";

                case PrivMsg:
                        return "PRIVMSG";

                case Quit:
                        return "QUIT";

                case Topic:
                        return "TOPIC";

                case Invalid:
                default:
                        return QString();
        }
}

IRCResponseType::MsgType IRCResponseType::typeFromRfcString(const QString& typeRepresentation)
{
        QString strTypeUpper = typeRepresentation.trimmed().toUpper();

        // Compare passed string against all known types.
        for (int i = 0; i < NUM_TYPES; ++i)
        {
                MsgType enumType = (MsgType) i;
                QString strCurrent = toRfcString(enumType);
                if (strTypeUpper == strCurrent)
                {
                        return enumType;
                }
        }

        return Invalid;
}