evaaddfriend.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2005 by yunfan                                          *
 *   yunfan_zg@163.com                                                     *
 *                                                                         *
 *   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.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/
#ifndef LIBEVAADDFRIEND_H
#define LIBEVAADDFRIEND_H

#include "evapacket.h"
#ifndef WIN32
#include <inttypes.h>
#endif
#include <string>

class AddFriendPacket : public OutPacket
{
public:
        AddFriendPacket();
        AddFriendPacket(const int id);
        AddFriendPacket(const AddFriendPacket &rhs);
        virtual ~AddFriendPacket() {};
        
        OutPacket *copy(){return new AddFriendPacket(*this);}
        AddFriendPacket &operator=( const AddFriendPacket &rhs );
        
        void setAddQQ(const int id) { qqNum = id; }
        const int getAddQQ() const { return qqNum; }
protected:
        virtual int putBody(unsigned char* buf);
private:
        int qqNum;
};

class AddFriendReplyPacket : public InPacket
{
public:
        AddFriendReplyPacket() {}
        AddFriendReplyPacket(unsigned char* buf, int len);
        AddFriendReplyPacket(const AddFriendReplyPacket &rhs);  
        virtual ~AddFriendReplyPacket() {};
        
        InPacket *copy() { return new AddFriendReplyPacket(*this); }
        AddFriendReplyPacket &operator=(const AddFriendReplyPacket &rhs);
        
        const int getMyQQ() const { return myQQ; }
        const uint8_t getReplyCode() const { return replyCode; }        
protected:
        virtual void parseBody();
private:                
        uint8_t replyCode;
        int myQQ;
};

class AddFriendAuthPacket : public OutPacket
{
public:
        AddFriendAuthPacket();
        AddFriendAuthPacket(const int id, const uint8_t type);
        AddFriendAuthPacket( AddFriendAuthPacket& rhs);
        
        virtual ~AddFriendAuthPacket() {};
        
        
        virtual OutPacket* copy(){return new AddFriendAuthPacket(*this);}
        AddFriendAuthPacket &operator=(const AddFriendAuthPacket &rhs);
        
        const std::string getMessage() const { return message; }
        void setMessage(const std::string &msg) { message = msg; }
        
        const int getBuddyQQ() const { return buddyQQNum; }
        void setBuddyQQ(const int id) { buddyQQNum = id; };
        
        const uint8_t getType() const { return type; }
        void setType(const uint8_t type) { this->type = type; }
protected:              
        virtual int putBody(unsigned char* buf);

private:
        static const unsigned char DIVIDER = 0x1f;
        uint8_t type;
        int buddyQQNum;
        std::string message;
};

class AddFriendAuthReplyPacket : public InPacket
{
public:
        AddFriendAuthReplyPacket() {}
        AddFriendAuthReplyPacket(unsigned char* buf, int len);
        AddFriendAuthReplyPacket(const AddFriendAuthReplyPacket &rhs);
        virtual ~AddFriendAuthReplyPacket() {};

        virtual InPacket* copy(){return new AddFriendAuthReplyPacket(*this);}
        AddFriendAuthReplyPacket &operator=(const AddFriendAuthReplyPacket &rhs);
        
        const uint8_t getReplyCode() const { return replyCode; }
        const bool isSentOK() const;
        
protected:
        virtual void parseBody();
private:
        uint8_t replyCode;
};

class DeleteFriendPacket : public OutPacket
{
public:
        DeleteFriendPacket();
        DeleteFriendPacket(const int id);
        DeleteFriendPacket(const DeleteFriendPacket &rhs);
        virtual ~DeleteFriendPacket() {};
        
        OutPacket *copy(){return new DeleteFriendPacket(*this);}
        DeleteFriendPacket &operator=(const DeleteFriendPacket &rhs);
        
        void setBuddyQQ(int id) { buddyQQNum = id; }
        const int getBuddyQQ() const { return buddyQQNum; }
protected:              
        virtual int putBody(unsigned char* buf);
private:
        int buddyQQNum;
};

class DeleteFriendReplyPacket : public InPacket
{
public:
        DeleteFriendReplyPacket() {}
        DeleteFriendReplyPacket(unsigned char* buf, int len);
        DeleteFriendReplyPacket( const DeleteFriendReplyPacket &rhs);
        virtual ~DeleteFriendReplyPacket() {};
                
        virtual InPacket* copy(){return new DeleteFriendReplyPacket(*this);}
        DeleteFriendReplyPacket &operator=(const DeleteFriendReplyPacket &rhs);
        
        const uint8_t getReplyCode() const { return replyCode; }
        const bool isDeleted() const;           
protected:
        virtual void parseBody();
private:
        uint8_t replyCode;

};

class DeleteMePacket : public OutPacket 
{
public:
        DeleteMePacket();
        DeleteMePacket(const int id);
        DeleteMePacket(const DeleteMePacket &rhs);
        virtual ~DeleteMePacket() {};
        
        OutPacket *copy(){return new DeleteMePacket(*this);}
        DeleteMePacket &operator=(const DeleteMePacket &rhs);
        
        void setBuddyQQ(int id) { buddyQQNum = id; }
        const int getBuddyQQ() const { return buddyQQNum; }
protected:              
        virtual int putBody(unsigned char* buf);
private:
        int buddyQQNum;
};

class DeleteMeReplyPacket : public InPacket
{
public:
        DeleteMeReplyPacket() {}
        DeleteMeReplyPacket(unsigned char* buf, int len);
        DeleteMeReplyPacket( const DeleteMeReplyPacket &rhs);
        virtual ~DeleteMeReplyPacket() {};
                
        virtual InPacket* copy(){return new DeleteMeReplyPacket(*this);}
        DeleteMeReplyPacket &operator=(const DeleteMeReplyPacket &rhs);
        
        const uint8_t getReplyCode() const { return replyCode; }
        const bool isDeleted() const;
protected:
        virtual void parseBody();
private:
        uint8_t replyCode;

};

class SystemNotificationPacket : public InPacket
{
public:
        SystemNotificationPacket() {};
        SystemNotificationPacket(unsigned char* buf, int len);
        SystemNotificationPacket( const SystemNotificationPacket &rhs); 
        virtual ~SystemNotificationPacket() {};
        
        virtual InPacket* copy(){return new SystemNotificationPacket(*this);}
        SystemNotificationPacket &operator=(const SystemNotificationPacket &rhs); 
        
        const uint8_t getType() const { return type; }
        const int getMyQQ() const { return myQQ; }
        const int getFromQQ() const { return fromQQ; }
        const std::string getMessage() const { return message; }
protected:              
        virtual void parseBody();
private:
        static const uint8_t DIVIDER = 0x1f;
        uint8_t type;
        int fromQQ;
        int myQQ;
        std::string message;
};

#endif

---