First commit

Author: swwelch

CMakeLists.txt

@@ -0,0 +1,14 @@
+cmake_minimum_required(VERSION 3.11.3)
+
+set(CMAKE_CXX_STANDARD 17)
+
+project(Membot)
+
+find_package(wxWidgets REQUIRED COMPONENTS core base)
+include(${wxWidgets_USE_FILE})
+
+file(GLOB project_SRCS src/*.cpp)
+
+add_executable(membot ${project_SRCS})
+target_link_libraries(membot ${wxWidgets_LIBRARIES})
+target_include_directories(membot PRIVATE ${wxWidgets_INCLUDE_DIRS})

README.md

@@ -0,0 +1,28 @@
+# CPPND: Memory Management Chatbot
+
+<img src="images/chatbot_demo.png"/>
+
+This is the project for the third course in the [Udacity C++ Nanodegree Program](https://www.udacity.com/course/c-plus-plus-nanodegree--nd213): Memory Management. 
+
+## Dependencies for Running Locally
+* cmake >= 2.8
+  * All OSes: [click here for installation instructions](https://cmake.org/install/)
+* make >= 4.1 (Linux, Mac), 3.81 (Windows)
+  * Linux: make is installed by default on most Linux distros
+  * Mac: [install Xcode command line tools to get make](https://developer.apple.com/xcode/features/)
+  * Windows: [Click here for installation instructions](http://gnuwin32.sourceforge.net/packages/make.htm)
+* gcc/g++ >= 5.4
+  * Linux: gcc / g++ is installed by default on most Linux distros
+  * Mac: same deal as make - [install Xcode command line tools](https://developer.apple.com/xcode/features/)
+  * Windows: recommend using [MinGW](http://www.mingw.org/)
+* wxWidgets >= 3.0
+  * Linux: `sudo apt-get install libwxgtk3.0-dev libwxgtk3.0-0v5-dbg`
+  * Mac: There is a [homebrew installation available](https://formulae.brew.sh/formula/wxmac).
+  * Installation instructions can be found [here](https://wiki.wxwidgets.org/Install). Some version numbers may need to be changed in instructions to install v3.0 or greater.
+
+## Basic Build Instructions
+
+1. Clone this repo.
+2. Make a build directory in the top level directory: `mkdir build && cd build`
+3. Compile: `cmake .. && make`
+4. Run it: `./membot`.

images/chatbot.png

@@ -0,0 +1,29 @@
+
+// define all graph nodes
+<TYPE:NODE><ID:0><ANSWER:Welcome! My name is MemBot. You can ask me about things related to memory management in C++. Possible topics are 'pointers' and 'the C++ memory model'. What would you like to talk about?>
+
+<TYPE:NODE><ID:1><ANSWER:Great! Let's talk about pointers. In computer science, a pointer is a special value whose meaning is a memory address. This address can contain either data, such as variables or objects, but also program codes (instructions). By dereferencing the pointer it is possible to access the data or the code. Among other things, pointers are used to manage dynamic memory. Other topics around pointers you can ask about are 'smart pointers' and 'nullptr'>
+
+<TYPE:NODE><ID:2><ANSWER:When instantiating variables, programmers can choose wether to do this on the heap, on the stack or in static memory. Do you want to know more about those two concepts? Simply ask me about 'heap', 'stack' or 'static'.>
+
+<TYPE:NODE><ID:3><ANSWER:A smart pointer is an object that behaves like a pointer, i.e. it must support pointer operations such as dereferencing or indirect access. In addition to these properties, the smart pointer handles resources better. In concrete terms, this means that it takes care not to cause a memory leak. A smart pointer exists in various flavors, which are unique_ptr, shared_ptr and weak_ptr. There are no more topics in this section, starting over!>
+
+<TYPE:NODE><ID:4><ANSWER:The value nullptr can be assigned to pointers of any type. This turns the pointer into a null pointer that does not point to a memory location. The nullptr keyword can be used to test if a pointer or handle reference is null before the reference is used. There are no more topics in this section, starting over!>
+
+<TYPE:NODE><ID:5><ANSWER:Local variables declared as part of a function are stored on the stack. Also, the stack is the place where function parameters are stored. Further, the stack is used for storing the return address of the calling functions, and it keeps the register contents and return address when an interrupt service routine is called. -- There are no more topics in this section, starting over!>
+
+<TYPE:NODE><ID:6><ANSWER:Heap memory, also known as dynamic memory, is an alternative to local stack memory. Local memory is allocated automatically on function call and it is deallocated automatically when a function exits. Heap memory is different. The programmer explicitly requests the allocation of a memory block of a particular size, and the block continues to be allocated until the programmer explicitly requests that it be deallocated. -- There are no more topics in this section, starting over!>
+
+<TYPE:NODE><ID:7><ANSWER:Static memory persists throughout the entire life of the program, and is usually used to store things like global variables, or variables created with the static clause. -- There are no more topics in this section, starting over!>
+
+
+// connect nodes with edges
+<TYPE:EDGE><ID:0><PARENT:0><CHILD:1><KEYWORD:pointer><KEYWORD:smart pointer>
+<TYPE:EDGE><ID:1><PARENT:0><CHILD:2><KEYWORD:memory model><KEYWORD:heap><KEYWORD:stack>
+
+<TYPE:EDGE><ID:2><PARENT:1><CHILD:3><KEYWORD:unique pointer><KEYWORD:shared pointer><KEYWORD:weak pointer>
+<TYPE:EDGE><ID:3><PARENT:1><CHILD:4><KEYWORD:NULL><KEYWORD:null pointer><KEYWORD:nullptr>
+
+<TYPE:EDGE><ID:4><PARENT:2><CHILD:5><KEYWORD:stack><KEYWORD:stack memory><KEYWORD:local variable storage>
+<TYPE:EDGE><ID:5><PARENT:2><CHILD:6><KEYWORD:heap><KEYWORD:heap memory><KEYWORD:dynamic storage>
+<TYPE:EDGE><ID:6><PARENT:2><CHILD:7><KEYWORD:static><KEYWORD:static memory><KEYWORD:global variable storage>

images/chatbot_demo.png

@@ -0,0 +1,106 @@
+#include <iostream>
+#include <random>
+#include <algorithm>
+#include <ctime>
+
+#include "chatlogic.h"
+#include "graphnode.h"
+#include "graphedge.h"
+#include "chatbot.h"
+
+void ChatBot::ReceiveUserQuery(std::string query)
+{
+    // loop over all edges and keywords and compute Levenshtein distance to query
+    typedef std::pair<GraphEdge*, int> EdgeDist;
+    std::vector<EdgeDist> levDists; // format is <ptr,levDist>
+    for (auto edge : _currentNode->GetEdgesToChildNodes())
+    {
+        for (auto keyword : edge->GetKeywords())
+        {
+            EdgeDist ed{edge, ComputeLevenshteinDistance(keyword, query)};
+            levDists.push_back(ed);
+        }
+    }
+
+    // select best fitting edge to proceed along
+    GraphNode *newNode;
+    if (levDists.size() > 0)
+    {
+        // sort in ascending order of Levenshtein distance (best fit is at the top)
+        std::sort(levDists.begin(), levDists.end(), [](const EdgeDist &a, const EdgeDist &b) { return a.second < b.second; });
+        newNode = levDists.at(0).first->GetChildNode(); // after sorting the best edge is at first position
+    }
+    else
+    {
+        // go back to root node
+        newNode = _rootNode;
+    }
+
+    // tell current node to move chatbot to new node
+    _currentNode->moveChatbotToNewNode(newNode);
+}
+
+void ChatBot::SetCurrentNode(GraphNode *node)
+{
+    // update pointer to current node
+    _currentNode = node;
+
+    // select a random node answer (if several answers should exist)
+    std::vector<std::string> answers = _currentNode->GetAnswers();
+    std::mt19937 generator(int(std::time(0)));
+    std::uniform_int_distribution<int> dis(0, answers.size() - 1);
+    std::string answer = answers.at(dis(generator));
+
+    // send selected node answer to user
+    _chatLogic->getChatBotPanelDialog()->printChatbotResponse(answer);
+}
+
+int ChatBot::ComputeLevenshteinDistance(std::string s1, std::string s2)
+{
+    // convert both strings to upper-case before comparing
+    std::transform(s1.begin(), s1.end(), s1.begin(), ::toupper);
+    std::transform(s2.begin(), s2.end(), s2.begin(), ::toupper);
+
+    // compute Levenshtein distance measure between both strings
+    const size_t m(s1.size());
+    const size_t n(s2.size());
+
+    if (m == 0)
+        return n;
+    if (n == 0)
+        return m;
+
+    size_t *costs = new size_t[n + 1];
+
+    for (size_t k = 0; k <= n; k++)
+        costs[k] = k;
+
+    size_t i = 0;
+    for (std::string::const_iterator it1 = s1.begin(); it1 != s1.end(); ++it1, ++i)
+    {
+        costs[0] = i + 1;
+        size_t corner = i;
+
+        size_t j = 0;
+        for (std::string::const_iterator it2 = s2.begin(); it2 != s2.end(); ++it2, ++j)
+        {
+            size_t upper = costs[j + 1];
+            if (*it1 == *it2)
+            {
+                costs[j + 1] = corner;
+            }
+            else
+            {
+                size_t t(upper < corner ? upper : corner);
+                costs[j + 1] = (costs[j] < t ? costs[j] : t) + 1;
+            }
+
+            corner = upper;
+        }
+    }
+
+    int result = costs[n];
+    delete[] costs;
+
+    return result;
+}

images/sf_bridge.jpg

@@ -0,0 +1,35 @@
+#ifndef CHATBOT_H_
+#define CHATBOT_H_
+
+#include <string>
+
+class GraphNode; // forward declaration
+class ChatLogic; // forward declaration
+
+class ChatBot
+{
+private:
+
+    // pointers to chatbot elements
+    GraphNode *_currentNode;
+    GraphNode *_rootNode;
+    ChatLogic *_chatLogic;
+
+    // proprietary functions
+    int ComputeLevenshteinDistance(std::string s1, std::string s2);
+
+public:
+    // constructors / destructors
+    ChatBot() {}
+
+    // getters / setters
+    void SetCurrentNode(GraphNode *node);
+    void SetRootNode(GraphNode *rootNode) { _rootNode = rootNode; }
+    void SetChatLogic(ChatLogic *chatLogic) { _chatLogic = chatLogic; }
+
+    // proprietary functions
+    void ReceiveUserQuery(std::string query);
+    
+};
+
+#endif /* CHATBOT_H_ */