evaqun.h

linux下的eva源代码

	QunAuthPacket &operator=(const QunAuthPacket &rhs);
protected:
	virtual int putBody(unsigned char *buf);
private:
	unsigned char type;
	unsigned int receiver;
	unsigned char *m_Code;
	unsigned short m_CodeLen;
	std::string message;
};

class QunSendIMPacket : public QunPacket {
public:
	QunSendIMPacket() {}
	QunSendIMPacket(const unsigned int id);  
	QunSendIMPacket(const QunSendIMPacket &rhs);
	virtual ~QunSendIMPacket();
	OutPacket * copy() { return new QunSendIMPacket(*this);}
	QunSendIMPacket &operator=(const QunSendIMPacket &rhs);
	
	const std::string &getFontName() const { return fontName; }               // font setting
	void setFontName(std::string &fontName) { this->fontName = fontName; }
	const char getFontSize() const { return fontSize; }
	void setFontSize(char fontSize); 
	const short getEncoding() const { return encoding; }
	void setEncoding(short encoding) { this->encoding = encoding; }

	const bool isUnderline() const { return underline;}                      // U B I setting
	void setUnderline(bool underline) ;
	const bool isItalic() const { return italic; }
	void setItalic(bool italic);
	const bool isBold() const { return bold; };
	void setBold(bool bold);
	
	const char getBlue() const { return blue; }                         // color setting
	void setBlue(char blue) { this->blue = blue; }
	const char getGreen() const { return green; }
	void setGreen(char green)  {this->green = green; }
	const char getRed() const { return red; }
	void setRed(char red) { this->red = red; }
	
	/*
	      the message is plain text, which means the smiley code is already
	      replaced with plain text.  
	*/
	const std::string &getMessage() const { return message; }              // message you want to send
	void setMessage(std::string message) { this->message = message; }   // and just put your plain text message here
protected:
	virtual int putBody(unsigned char *buf);
	
	short encoding;
	std::string fontName;
	char red, green, blue;
	bool bold, italic, underline;
	unsigned char fontSize;
	unsigned char fontFlag; 
	   
	std::string message; 
};

class QunSendIMExPacket : public QunSendIMPacket{
public: 
	QunSendIMExPacket() {}
	QunSendIMExPacket(const unsigned int id);  
	QunSendIMExPacket(const QunSendIMExPacket &rhs);
	virtual ~QunSendIMExPacket() {};
	OutPacket * copy() { return new QunSendIMExPacket(*this);}
	QunSendIMExPacket &operator=(const QunSendIMExPacket &rhs);
	
	const unsigned char getNumFragments() const { return numFragments; }
	const unsigned char getSeqOfFragments() const { return seqFragments; }
	const short getMessageID() const { return messageID; }
	
	void setNumFragments(const unsigned char num) { numFragments = num; }
	void setSeqOfFragments( const unsigned char seq) { seqFragments = seq; }
	void setMessageID(const short id) { messageID = id; }

protected:
	virtual int putBody(unsigned char *buf);
private:
	unsigned char numFragments;
	unsigned char seqFragments;
	static short messageID;
};

class QunSearchPacket : public QunPacket {
public:
	QunSearchPacket();
	QunSearchPacket(int type);  
	QunSearchPacket(const QunSearchPacket &rhs);
	virtual ~QunSearchPacket() {};
	
	const unsigned char getSearchType() const { return type; }
	const unsigned int getExtID() const { return externalID; }
	
	void setSearchType(const unsigned char t) { type = t; }
	void setExtID(const int id) { externalID = id; }
	
	QunSearchPacket &operator=(const QunSearchPacket &rhs);
protected:
	virtual int putBody(unsigned char *buf);
private:
	unsigned char type;
	unsigned int externalID;
};


class QunJoinPacket : public QunPacket {
public:
	QunJoinPacket() {}
	QunJoinPacket(const unsigned int id);  
	QunJoinPacket(const QunJoinPacket &rhs);
	virtual ~QunJoinPacket();
protected:
	virtual int putBody(unsigned char *buf);
};

class QunModifyPacket : public QunPacket {
public:
	QunModifyPacket() {}
	QunModifyPacket(const QunInfo &inf);  
	QunModifyPacket(const QunModifyPacket &rhs);
	virtual ~QunModifyPacket(){};
	
	const QunInfo &getQunInfo() const { return info; }
	
	QunModifyPacket &operator=(const QunModifyPacket &rhs);
protected:
	virtual int putBody(unsigned char *buf);
private:
	QunInfo info;
};

class QunRequestCardPacket :  public QunPacket {
public:
	QunRequestCardPacket() {}
	QunRequestCardPacket(const unsigned int qunID, const unsigned int qqID);  
	QunRequestCardPacket(const QunRequestCardPacket &rhs);
	virtual ~QunRequestCardPacket(){};
	
	const unsigned int getQQ() const { return qqNum; }
	QunRequestCardPacket &operator=(const QunRequestCardPacket &rhs);
protected:
	virtual int putBody(unsigned char *buf);
private:
	unsigned int qqNum;
};

class QunModifyCardPacket : public QunPacket {
public:
	QunModifyCardPacket() {}
	QunModifyCardPacket(const unsigned int qunID, const unsigned int qqID);  
	QunModifyCardPacket(const QunModifyCardPacket &rhs);
	virtual ~QunModifyCardPacket(){};
	
	const unsigned int getQQ() const { return qqNum; }
	const std::string &getName() const { return name;}
	const unsigned char getGender() const { return gender; }
	const std::string &getPhone() const { return phone;}
	const std::string &getEmail() const { return email;}
	const std::string &getMemo() const { return memo;}
	
	void setQQ(const unsigned int qqID) { qqNum = qqID; }
	void setName(const std::string &n) { name = n; }
	void setGender(const unsigned char g) { gender = g; }
	void setPhone(const std::string &ph) { phone = ph; }
	void setEmail(const std::string &e) { email = e; }
	void setMemo(const std::string &m) { memo = m; }
	
	
	QunModifyCardPacket &operator=(const QunModifyCardPacket &rhs);
protected:
	virtual int putBody(unsigned char *buf);
private:
	unsigned int qqNum;
	std::string name;
	unsigned char gender;
	std::string phone;
	std::string email;
	std::string memo;
};

class QunAdminOpPacket : public QunPacket {
public:
	QunAdminOpPacket() {}
	QunAdminOpPacket(const int id, const int qqID, const bool isSetAdmin);  
	QunAdminOpPacket(const QunAdminOpPacket &rhs);
	virtual ~QunAdminOpPacket() {};
	
	const unsigned int getQQ() const { return qqNum; }
	const unsigned char getActionCode() const { return action; }
	
	void setQQ(const unsigned int qq) { qqNum = qq; }
	void setActionCode( const unsigned char code) { action = code; }
	
	QunAdminOpPacket &operator=(const QunAdminOpPacket &rhs);
protected:
	virtual int putBody(unsigned char *buf);
private:
	unsigned int qqNum;
	unsigned char action;
};

class QunTransferPacket : public QunPacket {
public:
	QunTransferPacket() {}
	QunTransferPacket(const unsigned int id, const unsigned int qqID);  
	QunTransferPacket(const QunTransferPacket &rhs);
	virtual ~QunTransferPacket() {};
	
	const unsigned int getQQ() const { return qqNum; }
	void setQQ(const unsigned int qq) { qqNum = qq; }
	
	QunTransferPacket &operator=(const QunTransferPacket &rhs);
protected:
	virtual int putBody(unsigned char *buf);
private:
	unsigned int qqNum;
};


class QunModifyMemberPacket : public QunPacket {
public:
	QunModifyMemberPacket() {}
	QunModifyMemberPacket(const unsigned int id, const bool isAdd);  
	QunModifyMemberPacket(const QunModifyMemberPacket &rhs);
	virtual ~QunModifyMemberPacket() {};
	
	const std::list<unsigned int> &getMembers() const { return members; }
	const bool isAdd() const { return mIsAdd; }
	
	void setMembers(const std::list<unsigned int> list) { members=list; }
	void setAdd( const bool isAdd) { mIsAdd = isAdd; }
	
	QunModifyMemberPacket &operator=(const QunModifyMemberPacket &rhs);
protected:
	virtual int putBody(unsigned char *buf);
private:
	std::list<unsigned int> members;
	bool mIsAdd;
};

class QunExitPacket : public QunPacket {
public:
	QunExitPacket() {}
	QunExitPacket(const unsigned int id);  
	QunExitPacket(const QunExitPacket &rhs);
	virtual ~QunExitPacket() {};
	
	QunExitPacket &operator=(const QunExitPacket &rhs);
protected:
	virtual int putBody(unsigned char *buf);
};

class QunCreatePacket : public QunPacket {
public:
	QunCreatePacket() {}
	QunCreatePacket(const std::string &name, const unsigned short category, 
			const unsigned char auth = QQ_QUN_JOIN_NEED_AUTH);
	QunCreatePacket(const QunCreatePacket &rhs);
	
	void setNotice(const std::string &notice) { qunNotice = notice; }
	void setDescription(const std::string &desc) { qunDescription = desc; }
	void setMembers( const std::list<unsigned int> &members) { qunMembers = members; }
	
	const std::string & getName() const { return qunName; }
	const unsigned short getCategory() const { return qunCategory; }
	const unsigned char getAuth() const { return qunAuth; }
	
	const std::string & getNotice() const { return qunNotice; }
	const std::string & getDescription() const { return qunDescription; }
	const std::list<unsigned int> & getMembers() const { return qunMembers; }
	
	QunCreatePacket &operator=(const QunCreatePacket &rhs);
	
protected:
	virtual int putBody(unsigned char *buf);
private:
	unsigned char qunAuth;
	unsigned short qunCategory;
	std::string qunName;
	std::string qunNotice;
	std::string qunDescription;
	std::list<unsigned int> qunMembers;
};

class QunActivePacket : public QunPacket {
public:
	QunActivePacket() {}
	QunActivePacket(const unsigned int id);  
	QunActivePacket(const QunActivePacket &rhs);
	virtual ~QunActivePacket() {};
	
	QunActivePacket &operator=(const QunActivePacket &rhs);
protected:
	virtual int putBody(unsigned char *buf);	
};

class QunRequestAllRealNames : public QunPacket {
public:
	QunRequestAllRealNames() {}
	QunRequestAllRealNames(const unsigned int id); 
	QunRequestAllRealNames(const QunRequestAllRealNames &rhs);
	virtual ~QunRequestAllRealNames() {};

	void setStartIndex(const unsigned int index) { m_StartIndex = index; }
	const unsigned int getStartIndex() const { return m_StartIndex; }

	QunRequestAllRealNames &operator=(const QunRequestAllRealNames &rhs);
protected:
	virtual int putBody(unsigned char *buf);
private:
	unsigned int m_StartIndex;
};

#endif