How to handle the often-generated messages? - algorithm

Question

I have the following system:
producer ---> proxy ---> consumer
<good> 10 msg/s
A producer that generates messages - 10 msg/second. A proxy that returns bool value to a consumer depends on how many messages producer generated, if it generate more than 10, proxy returns false.
This is timestamp:
0.1
0.2
0.25
0.26
0.27
0.28
0.29
0.30
0.31
0.32
0.33
0.34
2.0
2.1
2.2
Messages that comes at 0.1, 0.2, 0.25 ... 0.32 they are good and we return true, 0.32 is bad because it's 11th message in 1 second, so we return false.
Here is a protoype:
bool shouldProxyAcceptMessage(float timestamp)
How can I implement this algorithm?

Answer 1

Okay, I adapted the solution based on the OP's comments. The algorithm uses two global variables, nrMessages and startTime, and it initializes startTime to the current time whenever nrMessage==0 (i.e. when it receives the first message); it returns true for the first 10 timestamps that arrived within 1 second. Once it receives a timestamp older than 1 second, it resets nrMessages=0 (so startTime will reinitialize when the next timestamp arrives).
An implicit assumption we're
long nrMessages = 0; // global variable
long startTime = 0;
boolean shouldProxyAcceptMessage(long timestamp) {
if (nrMessages++ == 0) {
startTime = System.currentTimeMillis()();
}
timeDiff = timestamp-startTime;
if (timeDiff > 1000) {
nrMessages = 0;
return false;
} else {
return nrMessages <= 10;
}
}