Creating ConcurrentLinkedListQueue for C++

diff --git a/iotjava/iotrmi/C++/ConcurrentLinkedListQueue.cpp b/iotjava/iotrmi/C++/ConcurrentLinkedListQueue.cpp
new file mode 100644 (file)
index 0000000..3fd0273
--- /dev/null
+++ b/iotjava/iotrmi/C++/ConcurrentLinkedListQueue.cpp
@@ -0,0 +1,175 @@
+#include <iostream>
+#include <thread>
+
+#include "ConcurrentLinkedListQueue.hpp"
+
+using namespace std;
+
+
+Node::Node(void* val) {
+
+       value = val;
+       next = NULL;
+}
+
+
+Node::~Node() {
+
+       /*if (next != NULL) {
+               delete next;
+               next = NULL;
+       }
+       if (value != NULL) {
+               delete value;
+               value = NULL;
+       }*/
+}
+
+
+void* Node::getValue() {
+
+       return value;
+}
+
+
+Node* Node::getNext() {
+
+       return next;
+}
+
+
+void Node::setNext(Node* nxt) {
+
+       next = nxt;
+}
+
+
+ConcurrentLinkedListQueue::ConcurrentLinkedListQueue() {
+
+       tail = NULL;
+       head = NULL;
+}
+
+
+ConcurrentLinkedListQueue::~ConcurrentLinkedListQueue() {
+
+       void* val = NULL;
+       do {    // Dequeue and free everything up
+               val = dequeue();
+       } while(val != NULL);
+}
+
+
+void ConcurrentLinkedListQueue::enqueue(void* value) {
+
+       lock_guard<mutex> guard(mtx);
+       if (tail == NULL && head == NULL) {     // first element
+               tail = new Node(value);
+               head = tail;    // Both tail and head point to the first element
+       } else {        // Next elements
+               Node* newEl = new Node(value);
+               tail->setNext(newEl);
+               tail = newEl;
+       }
+}
+
+
+// Return element and remove from list
+void* ConcurrentLinkedListQueue::dequeue() {
+
+       lock_guard<mutex> guard(mtx);
+       if (tail == NULL && head == NULL) {     // empty
+               return NULL;
+       } else {
+               Node* retEl = head;
+               if (head->getNext() == NULL) {
+                       head = NULL;
+                       tail = NULL;
+               } else
+                       head = head->getNext();
+               void* retVal = retEl->getValue();
+               // Prepare retEl for deletion
+               retEl->setNext(NULL);
+               delete retEl;
+               // Return just the value
+               return retVal;
+       }
+}
+
+
+void enQ(ConcurrentLinkedListQueue* methodQueue, char** test) {
+
+       /*char* test = new char[3];
+       test[0] = 'a';
+       test[1] = 'b';
+       test[2] = 'c';*/
+       void* ptr = test;
+       for(int i=0; i<10; i++ ) {
+               cout << "Enqueuing: " << test << " address: " << ptr << endl;
+               methodQueue->enqueue(ptr);
+       }
+}
+
+
+void deQ(ConcurrentLinkedListQueue* methodQueue) {
+
+       for(int i=0; i<12; i++) {
+               void* result = methodQueue->dequeue();
+               if (result != NULL) {
+                       cout << "Dequeue result: " << result << endl;
+                       cout << "Dequeue result: " << *((char**) result) << endl;               
+               } else {
+                       cout << "Result is NULL!!! End of queue!" << endl;
+               }
+       }
+}
+
+
+int main(int argc, char *argv[])
+{
+       ConcurrentLinkedListQueue* methodQueue = new ConcurrentLinkedListQueue();
+       /*cout << "Dequeue result: " << methodQueue->dequeue() << endl;
+       string str = "this is a test string";
+       const char* test = str.c_str();
+       const char** test2 = &test;
+       cout << "Initial result: " << test << endl;
+       cout << "Initial result 2: " << *test2 << endl;
+       void* ptr = &test;
+       cout << "Pointer: " << ptr << endl;
+       methodQueue->enqueue(ptr);
+       methodQueue->enqueue(ptr);
+       void* result = methodQueue->dequeue();
+       cout << "Result: " << result << endl;
+       cout << "Dequeue result: " << *((const char**) result) << endl;
+       void* result2 = methodQueue->dequeue();
+       cout << "Dequeue result: " << *((const char**) result2) << endl;
+       void* result3 = methodQueue->dequeue();
+       cout << "Dequeue result: " << result3 << endl;*/
+       //thread t1,t2;
+
+       //t1 = thread(enQ, methodQueue);
+       //t2 = thread(deQ, methodQueue);
+
+       //t1.join();
+       //t2.join();
+
+       char* test = new char[3];
+       test[0] = 'a';
+       test[1] = 'b';
+       test[2] = 'c';
+       void* ptr = &test;
+       methodQueue->enqueue(ptr);
+       void* result = methodQueue->dequeue();
+       cout << "Dequeue result: " << *((char**) result) << endl;
+
+       thread t1,t2;
+
+       t1 = thread(enQ, methodQueue, &test);
+       t2 = thread(deQ, methodQueue);
+
+       t1.join();
+       t2.join();
+
+       return 0;
+}
+

diff --git a/iotjava/iotrmi/C++/ConcurrentLinkedListQueue.hpp b/iotjava/iotrmi/C++/ConcurrentLinkedListQueue.hpp
new file mode 100644 (file)
index 0000000..e18e5e4
--- /dev/null
+++ b/iotjava/iotrmi/C++/ConcurrentLinkedListQueue.hpp
@@ -0,0 +1,48 @@
+#ifndef _CONCURRENTLINKEDLISTQUEUE_HPP__
+#define _CONCURRENTLINKEDLISTQUEUE_HPP__
+#include <iostream>
+#include <mutex>
+
+/** Class ConcurrentLinkedListQueue is a queue that can handle
+ *  concurrent requests and packets for IoT communication via socket.
+ *  <p>
+ *  It stores object through a void pointer.
+ *
+ * @author      Rahmadi Trimananda <rtrimana @ uci.edu>
+ * @version     1.0
+ * @since       2017-01-27
+ */
+
+using namespace std;
+
+mutex mtx;
+
+class Node {
+
+       private:
+               Node* next;
+               void* value;
+
+       public:
+               Node(void* val);
+               ~Node();
+               void* getValue();
+               Node* getNext();
+               void setNext(Node* nxt);
+
+};
+
+
+class ConcurrentLinkedListQueue {
+
+       private:
+               Node* tail;
+               Node* head;
+
+       public:
+               ConcurrentLinkedListQueue();
+               ~ConcurrentLinkedListQueue();
+               void enqueue(void* value);      // Enqueue to tail
+               void* dequeue();                        // Dequeue from tail
+};
+#endif