Dan sliding window

course02/homework02/danielellis/Buffer.h

@@ -0,0 +1,79 @@
+#pragma once
+
+#include <deque>
+#include <chrono>
+#include <vector>
+#include <stdexcept>
+
+struct WindowConfig
+{
+	std::chrono::seconds mDuration = std::chrono::seconds(10);
+	int mMaxNumMessages = 5;
+};
+
+template<class Message>
+struct TimestampedMessage
+{
+	std::chrono::time_point<std::chrono::steady_clock> mTimestamp;
+	Message mMessage;
+};
+
+template<class Message>
+class Buffer
+{
+public:
+	using value_type = Message;
+
+	Buffer(const WindowConfig& conf);
+	void TryToAddMessage(const Message& message);
+	std::vector<Message> DumpMessages() const;
+
+private:
+	bool CanAddMessage(std::chrono::time_point<std::chrono::steady_clock> currentTime) const;
+
+	WindowConfig mWindowConfig;
+	std::deque<TimestampedMessage<Message> > mTimestampedMessages;
+};
+
+template<class Message>
+Buffer<Message>::Buffer(const WindowConfig& conf) :
+		mWindowConfig(conf)
+{
+	if (conf.mMaxNumMessages <= 0)
+		throw std::runtime_error("Invalid configuration: max number of messages per time window must be positive!");
+}
+
+template<class Message>
+bool Buffer<Message>::CanAddMessage(std::chrono::time_point<std::chrono::steady_clock> currentTime) const
+{
+	if (mTimestampedMessages.size() >= mWindowConfig.mMaxNumMessages)
+	{
+		auto timestampAtStartOfWindow = mTimestampedMessages[
+				mTimestampedMessages.size()	- mWindowConfig.mMaxNumMessages].mTimestamp;
+		return (timestampAtStartOfWindow < currentTime - mWindowConfig.mDuration);
+	}
+	return true;
+}
+
+template<class Message>
+void Buffer<Message>::TryToAddMessage(const Message& message)
+{
+	auto currentTime = std::chrono::steady_clock::now();
+	if (CanAddMessage(currentTime))
+	{
+		TimestampedMessage<Message> tsMsg;
+		tsMsg.mMessage = message;
+		tsMsg.mTimestamp = currentTime;
+		mTimestampedMessages.push_back(tsMsg);
+	}
+}
+
+template<class Message>
+std::vector<Message> Buffer<Message>::DumpMessages() const
+{
+	std::vector<Message> result;
+	for (auto tsMsg : mTimestampedMessages)
+		result.push_back(tsMsg.mMessage);
+
+	return result;
+}

course02/homework02/danielellis/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 2.8)
+
+set(sources
+	main.cc
+	SlidingWindow.h
+        Buffer.h
+)
+
+add_executable(main ${sources})

course02/homework02/danielellis/SlidingWindow.h

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <map>
+#include <queue>
+#include <chrono>
+#include <vector>
+
+#include "Buffer.h"
+
+template<class Message>
+class SlidingWindow
+{
+public:
+	using value_type = Message;
+
+	SlidingWindow(const WindowConfig& conf);
+	void Send(int clientId, const Message& message);
+	std::vector<Message> DumpMessages(int clientId) const;
+
+private:
+	WindowConfig mWindowConfig;
+	std::map<int, Buffer<Message> > mClientBuffers;
+};
+
+template<class Message>
+SlidingWindow<Message>::SlidingWindow(const WindowConfig& conf) :
+		mWindowConfig(conf)
+{
+	if (conf.mMaxNumMessages <= 0)
+		throw std::runtime_error("Invalid configuration: max number of messages per time window must be positive!");
+}
+
+template<class Message>
+void SlidingWindow<Message>::Send(int clientId, const Message& message)
+{
+	if (mClientBuffers.count(clientId) == 0)
+		mClientBuffers.insert(std::pair<int, Buffer<Message> >(clientId, Buffer<Message>(mWindowConfig)));
+
+	Buffer<Message>& buffer = mClientBuffers.at(clientId);
+	buffer.TryToAddMessage(message);
+}
+
+template<class Message>
+std::vector<Message> SlidingWindow<Message>::DumpMessages(int clientId) const
+{
+	auto buffer = mClientBuffers.find(clientId);
+	if (buffer != mClientBuffers.end())
+		return buffer->second.DumpMessages();
+	else
+		return std::vector<Message>();
+}

course02/homework02/danielellis/main.cc

@@ -0,0 +1,84 @@
+#include "SlidingWindow.h"
+#include "Buffer.h"
+
+#include <assert.h>
+
+void TestDroppedLastMessage()
+{
+	WindowConfig conf;
+	auto slidingWindow = SlidingWindow<int>(conf);
+	for (int i = 1; i < 7; ++i)
+		slidingWindow.Send(1, i);
+
+	auto messageDump = slidingWindow.DumpMessages(1);
+	assert(messageDump.size() == 5);
+	int i = 1;
+	for (auto msg : messageDump)
+	{
+		assert(msg == i);
+		++i;
+	}
+}
+
+void TestMultipleClients()
+{
+	WindowConfig conf;
+	conf.mMaxNumMessages = 8;
+	auto slidingWindow = SlidingWindow<int>(conf);
+	for (int i = 1; i < 7; ++i)
+		slidingWindow.Send(1, i);
+
+	for (int i = 1; i < 15; ++i)
+		slidingWindow.Send(2, i);
+
+	auto messageDump = slidingWindow.DumpMessages(1);
+	assert(messageDump.size() == 6);
+	int i = 1;
+	for (auto msg : messageDump)
+	{
+		assert(msg == i);
+		++i;
+	}
+
+	messageDump = slidingWindow.DumpMessages(2);
+	assert(messageDump.size() == 8);
+	i = 1;
+	for (auto msg : messageDump)
+	{
+		assert(msg == i);
+		++i;
+	}
+}
+
+void TestDumpQuietClient()
+{
+	WindowConfig conf;
+	auto slidingWindow = SlidingWindow<int>(conf);
+	auto dump = slidingWindow.DumpMessages(1);
+	assert(dump.size() == 0);
+}
+
+void TestNegativeNumMessagesInWindowConf()
+{
+	WindowConfig conf;
+	conf.mMaxNumMessages = -5;
+	bool failed = true;
+	try
+	{
+		auto slidingWindow = SlidingWindow<int>(conf);
+	}
+	catch (std::exception e)
+	{
+		failed = false;
+	}
+	assert(!failed);
+}
+
+int main()
+{
+	TestDroppedLastMessage();
+	TestMultipleClients();
+	TestDumpQuietClient();
+	TestNegativeNumMessagesInWindowConf();
+	return 0;
+}