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
|
/***************************************************************************
* Copyright (C) 2005 by Joris Guisson *
* [email protected] *
* *
* 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. *
***************************************************************************/
#ifndef BTCAP_H
#define BTCAP_H
#if 0
#include <qvaluelist.h>
#include <util/timer.h>
#include <util/constants.h>
namespace bt
{
/**
* Base class for all cappable objects.
*/
class Cappable
{
public:
/**
* Proceed with doing some bytes
* @param bytes The number of bytes it can do (0 = no limit)
* @return true if finished, false otherwise
*/
virtual void proceed(Uint32 bytes) = 0;
};
/**
* @author Joris Guisson <[email protected]>
*
* A Cap is something which caps something.
*/
class Cap
{
public:
Cap(bool percentage_check);
virtual ~Cap();
struct Entry
{
Cappable* obj;
Uint32 num_bytes;
Entry() : obj(0),num_bytes(0) {}
Entry(Cappable* obj,Uint32 nb) : obj(obj),num_bytes(nb) {}
};
/**
* Set the speed cap in bytes per second. 0 indicates
* no limit.
* @param max Maximum number of bytes per second.
*/
void setMaxSpeed(Uint32 max);
/// Get max bytes/sec
Uint32 getMaxSpeed() const {return max_bytes_per_sec;}
/// Set the current speed
void setCurrentSpeed(Uint32 cs) {current_speed = cs;}
/// Get the current speed
Uint32 getCurrrentSpeed() const {return current_speed;}
/**
* Allow or disallow somebody from proceeding. If somebody
* is disallowed they will be stored in a queue, and will be notified
* when there turn is up.
* @param pd Thing which is doing the request
* @param bytes Bytes it wants to send
* @return true if the piece is allowed or not
*/
bool allow(Cappable* pd,Uint32 bytes);
/**
* A thing in the queue should call this when it get destroyed. To
* remove them from the queue.
* @param pd The Cappable thing
*/
void killed(Cappable* pd);
/**
* Update the downloadcap.
*/
void update();
private:
QValueList<Entry> entries;
Uint32 max_bytes_per_sec;
Timer timer;
Uint32 leftover;
Uint32 current_speed;
bool percentage_check;
};
}
#endif
#endif
|
