1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
/*
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) version 2.
*/
/*
Copyright (C) 2008 Eli J. MacKenzie <argonel at gmail.com>
*/
#ifndef IRCQUEUE_H
#define IRCQUEUE_H
class Server;
//channel.cpp, outputfilter.cpp, query.cpp, server.cpp, statuspanel.cpp
/**
* A message from or to an IRC server.
*
* Contains all we know about the message, which currently consists of the text, the time it was created,
* and its original encoding. (Since currently these objects are only used internally, we know the message
* is Unicode.)
*/
struct IRCMessage
{
IRCMessage() : t(TQTime::currentTime()) //, codec(TQTextCodec::codecForName("utf8"))
{} ///< this constructor required for TQValueList, do not use
/**
Make a new IRCMessage with timestamp of TQTime::currentTime().
Note the constructor takes a TQString, not a const TQString& or a TQString *. If you want to modify the
contained text, put it back with setText.
*/
IRCMessage(TQString i) : s(i), t(TQTime::currentTime()) //, codec(TQTextCodec::codecForName("utf8"))
{}
TQString text() { return s; }
int age() { return t.elapsed(); }
TQTime time() { return t; }
void setText(TQString text) { s=text; }
private:
TQString s;
TQTime t;
//FIXME wire this up
//TQTextCodec* codec;
//operator const char * () const { return codec->fromUnicode(text()); }
};
/**
* Provides a self-sending queue of IRCMessages.
*
* Messages enqueued in this server can only be erased via reset() or sent to the attached server.
* The server and the emptying rates cannot be changed, if you want to do that construct a new queue.
*/
class IRCQueue: public TQObject
{
Q_OBJECT
public:
struct EmptyingRate
{
enum RateType {
Lines, ///< Lines per interval.
Bytes ///< Bytes per interval. Not implemented. FIXME
};
EmptyingRate(int rate=6, int msec_interval=50000, RateType type=Lines):
m_rate(rate), m_interval(msec_interval), m_type(type)
{
}
int nextInterval(int byte_size, int msec_since_last);
int m_rate;
int m_interval;
RateType m_type;
bool isValid() { return m_rate > 0; }
};
IRCQueue(Server *server, EmptyingRate& rate, int myindex=0);
~IRCQueue();
void enqueue(TQString line);
void reset();
EmptyingRate& getRate();// { return &m_rate; }
bool isValid() { return m_rate.isValid(); }
bool isEmpty() { return m_pending.isEmpty(); }
//WTF? why are there two of these.
//These are decoupled for a reason, what is it?
int currentWait(); ///< Time in ms that the front has been waiting
int elapsed(); ///< How long has the queue been running since it was last started?
int nextSize(); ///< Current size of front
int pendingMessages() { return m_pending.count(); }
int linesSent() const; ///< count of lines sent by this queue
int bytesSent() const; ///< count of bytes sent by this queue
///Time in milliseconds that the previous message waited
int lastWait() { return m_lastWait; }
public slots:
void sent(int bytes, int encodedBytes, IRCQueue *); ///< feedback statistics
void sendNow(); ///< dumps a line to the socket
void serverOnline(bool on); ///< server tells us that the socket is ready
protected:
TQString pop(); ///< pops front, sets statistics
void adjustTimer(); ///< sets the next timer interval
bool doSend(); ///< pops front and tells the server to send it. returns true if we sent something
EmptyingRate& m_rate;
private:
TQValueList<IRCMessage> m_pending;
TQTimer *m_timer;
bool m_blocked;
bool m_online;
Server *m_server;
TQTime m_startedAt;
TQTime m_lastSent, m_globalLastSent;
int m_linesSent, m_globalLinesSent;
int m_bytesSent, m_globalBytesSent;
int m_lastWait;
int m_myIndex;
};
extern IRCQueue::EmptyingRate staticrates[];
#endif
|
