message queue

course02/homework01/matt/linked_list.cc

@@ -1,4 +1,7 @@
 
+// Linked List
+#include <algorithm>
+
 template<typename T>
 LinkedList<T>::LinkedList() {}
 
@@ -28,7 +31,6 @@ void LinkedList<T>::Append(const T& data)
 	 if(mFirst==nullptr)
 	 {
 		mFirst = std::make_unique<Node<T>>(data);
-		std::cout << mFirst->mData << std::endl;
 		mLast = mFirst.get();
 	}
 	else
@@ -40,3 +42,50 @@ void LinkedList<T>::Append(const T& data)
 	 mSize++;
 }
 
+//Linked List Iterator
+
+template<typename T>
+LinkedListIterator<T> LinkedList<T>::begin()
+{
+  return LinkedListIterator<T>{mFirst.get()};
+}
+
+template<typename T>
+LinkedListIterator<T> LinkedList<T>::end()
+{
+  return LinkedListIterator<T>{mLast->mNext.get()};
+}
+
+template<typename T>
+std::ostream& operator<<(std::ostream& stream, const LinkedList<T>& list)
+{
+	Node<T>* ptrNode = list.mFirst.get();
+	while(ptrNode != nullptr)
+	{
+		stream << ptrNode->mData << ", ";
+		ptrNode = ptrNode->mNext.get();
+	}
+
+	return stream;
+}
+
+template<typename T>
+LinkedListIterator<T>::LinkedListIterator(Node<T>* ptrNode) : mPtrNode(ptrNode){}
+
+template<typename T>
+LinkedListIterator<T>& LinkedListIterator<T>::operator++()
+{
+	mPtrNode = mPtrNode->mNext.get();
+}
+
+template<typename T>
+bool LinkedListIterator<T>::operator !=(const LinkedListIterator& other)
+{
+   return mPtrNode != other.mPtrNode;
+}
+
+template<typename T>
+T& LinkedListIterator<T>::operator*()
+{
+   return mPtrNode->mData;
+}

course02/homework01/matt/linked_list.h

@@ -11,6 +11,9 @@ struct Node
 	std::unique_ptr<Node<T>> mNext;
 };
 
+template<typename T>
+class LinkedListIterator;
+
 template<typename T>
 class LinkedList
 {
@@ -24,22 +27,33 @@ class LinkedList
 
 	void Append(const T& data);
 
-	friend std::ostream& operator<<(std::ostream& stream, const LinkedList& list)
-	{
-	    Node<T>* ptrNode = list.mFirst.get();
-	    while(ptrNode != nullptr)
-	    {
-	        stream << ptrNode->mData << ", ";
-	        ptrNode = ptrNode->mNext.get();
-	    }
-
-		return stream;
-	}
+	LinkedListIterator<T> begin();
+  	LinkedListIterator<T> end();
+
+	template<typename U>
+	friend std::ostream& operator<<(std::ostream& stream, const LinkedList<U>& list);
 
 private:
+
 	std::unique_ptr<Node<T>> mFirst;
 	Node<T>* mLast;
 	int mSize {};
 };
 
+template<typename T>
+class LinkedListIterator: public std::iterator<std::input_iterator_tag, T, T, const T*, T>
+{
+public:
+  explicit LinkedListIterator(Node<T>* ptrNode);
+
+  LinkedListIterator& operator++();
+
+  bool operator !=(const LinkedListIterator& other);
+
+  T& operator*();
+
+private:
+   Node<T>* mPtrNode;
+};
+
 #include "linked_list.cc"

course02/homework01/matt/test_linked_list.cc

@@ -1,5 +1,6 @@
 #include <iostream>
 #include "linked_list.h"
+#include <algorithm>
 
 int main()
 {
@@ -8,15 +9,23 @@ int main()
 	l.Append(2);
 	l.Append(3);
 
-	std::cout << "l:" << l << std::endl;
+	std::cout << "l: " << l << std::endl;
 
 	LinkedList<int> lCopyConstructed(l);
-	std::cout << "lCopyConstructed:" << lCopyConstructed << std::endl;
+	std::cout << "lCopyConstructed: " << lCopyConstructed << std::endl;
 
 	LinkedList<int> lAssigned;
 	lAssigned = l;
-	std::cout << "lAssigned:" << lAssigned << std::endl;
+	std::cout << "lAssigned: " << lAssigned << std::endl;
+
+	std::cout << "iterator: ";
+	for(auto i: l)
+	std::cout << i << ", ";
+	std::cout << std::endl;
+
+    std::cout << "algorithm: ";
+	std::for_each(l.begin(), l.end(), [](int& i) { std::cout << i << ", " ; });
+	std::cout << std::endl;
 
 	return 0;
 }
-

course02/homework03/matt/test_throttle.cc

@@ -0,0 +1,28 @@
+#include "throttle.cc"
+#include <iostream>
+#include <sstream>
+#include <thread>
+
+int main()
+{
+	Throttle throttle;
+
+	UserID id = 5;
+
+	int i = 0;
+	for(; i<=20; i++)
+	{
+		std::ostringstream stringStream;
+		stringStream << "Hello " << i;
+		throttle.SendMessage(id, stringStream.str());
+	}
+	std::this_thread::sleep_for(std::chrono::milliseconds(10000));
+
+	for(; i<=40; i++)
+	{
+		std::this_thread::sleep_for(std::chrono::milliseconds(800));
+		std::ostringstream stringStream;
+		stringStream << "Hello " << i;
+		throttle.SendMessage(id, stringStream.str());
+	}
+}

course02/homework03/matt/throttle.cc

@@ -0,0 +1,50 @@
+#include "throttle.h"
+
+typedef std::chrono::milliseconds ms;
+typedef std::chrono::duration<double> fsec;
+
+template<class duration>
+double DurationToMillis(duration d)
+{
+	return std::chrono::duration_cast<std::chrono::milliseconds>(d).count();
+}
+
+void Throttle::SendMessage(UserID id, std::string message)
+{
+	FlushMessages(id);
+
+	TimestampedMessage tsm{message};
+	auto& queue = mQueues[id];
+
+	Timestamp arrivalTime = Clock::now();
+
+	auto timeBetweenFirstLast = arrivalTime - queue.front().mArrivalTime;
+	auto timeToWait = mMessageInterval - timeBetweenFirstLast;
+	double millisToWait = DurationToMillis(timeToWait);
+
+	if(queue.size() >= mMaxQueueSize)
+	{
+		printf("user %d message %s dropped, please wait %.0f millis  \n", id, message.c_str(), millisToWait);
+	}
+	else
+	{
+		printf("user %d message %s accepted  \n", id, message.c_str());
+		queue.emplace_back(TimestampedMessage{message, arrivalTime});
+	}
+}
+
+void Throttle::FlushMessages(UserID id)
+{
+	auto& queue = mQueues[id];
+	Timestamp now = Clock::now();
+	while (!queue.empty())
+	{
+		if (now - queue.front().mArrivalTime > mMessageInterval)
+		{
+			printf("user %d message %s popping \n", id, queue.front().mText.c_str());
+			queue.pop_front();
+		}
+		else
+			break;
+	}
+}

course02/homework03/matt/throttle.h

@@ -0,0 +1,34 @@
+#include <chrono>
+#include <unordered_map>
+#include <deque>
+#include <string>
+
+typedef int UserID;
+typedef std::chrono::high_resolution_clock Clock;
+typedef std::chrono::time_point<Clock> Timestamp;
+
+
+struct TimestampedMessage
+{
+	TimestampedMessage(std::string message, Timestamp ts):
+			mText(message), mArrivalTime(ts) {};
+
+	TimestampedMessage(std::string message):
+			mText(message), mArrivalTime(Clock::now()) {};
+
+	std::string mText;
+	Timestamp mArrivalTime;
+};
+
+class Throttle
+{
+public:
+	void SendMessage(UserID id, std::string message);
+
+private:
+	void FlushMessages(UserID id);
+
+	const int mMaxQueueSize = 10;
+	const std::chrono::milliseconds mMessageInterval{10000};
+	std::unordered_map<UserID, std::deque<TimestampedMessage>> mQueues;
+};