using uint for non negative numbers

others/lru_cache.cpp

@@ -59,20 +59,20 @@ namespace others {
  * @namespace lru_cache
  * @brief Implementation of LRU caching algorithm
  */
-namespace lru_cache {
+    namespace lru_cache {
 
 /**
  * @brief LRU cache class
  */
-class LRUCache {
+        class LRUCache {
-    int pageFrame;         ///< Page frame, or total size of the cache.
+            uint64_t pageFrame;         ///< Page frame, or total size of the cache.
-    std::list<int> cache;  ///< Cache linked list (using the STL)
+            std::list<uint64_t> cache;  ///< Cache linked list (using the STL)
-    std::unordered_map<int, std::list<int>::iterator>
+            std::unordered_map<uint64_t , std::list<uint64_t >::iterator>
                     pageMap;  ///< Hash map containing pages and their addresses
 
-    int hits = 0;  ///< Total number of hits, or total number of times a page
+            uint64_t hits = 0;  ///< Total number of hits, or total number of times a page
             ///< was found in cache.
-    int pageFault = 0;  ///< Total number of miss/page fault, or total number of
+            uint64_t pageFault = 0;  ///< Total number of miss/page fault, or total number of
             ///< times a page was not found in cache
 
         public:
@@ -80,14 +80,14 @@ class LRUCache {
              * @brief Constructor, Initialize thee LRU class with page frame.
              * @param pf Page frame or total size of cache.
              * */
-    explicit LRUCache(int pf) { pageFrame = pf; }
+            explicit LRUCache(uint64_t pf) { pageFrame = pf; }
 
             /**
              * @brief Refer to a page, or request a page from memory.
              * @param page The page that you are referring to.
              * @returns void
              * */
-    void refer(int page) {
+            void refer(uint64_t page) {
                 // If the page requested not in cache.
                 if (pageMap.find(page) == pageMap.end()) {
                     pageFault++;  ///< Increase the page fault by one.
@@ -95,7 +95,7 @@ class LRUCache {
                     // Check if the cache is full
                     if (cache.size() == pageFrame) {
                         // delete the last page from cache
-                int lastPage = cache.back();
+                        uint64_t lastPage = cache.back();
                         cache.pop_back();
                         pageMap.erase(lastPage);
                     }
@@ -117,7 +117,7 @@ class LRUCache {
              * @returns Void
              * */
             void display() {
-        for (int &it : cache) {
+                for (uint64_t &it : cache) {
                     std::cout << it << " ";
                 }
                 std::cout << std::endl;
@@ -126,15 +126,15 @@ class LRUCache {
              * @brief A function to get page hits
              * @returns int
              * */
-    int getHits() const { return hits; }
+            uint64_t getHits() const { return hits; }
             /**
              * @brief A function to get page fault
              * @returns int
              * */
-    int getPageFault() const { return pageFault; }
+            uint64_t getPageFault() const { return pageFault; }
-};
+        };
 
-}  // namespace lru_cache
+    }  // namespace lru_cache
 }  // namespace others
 
 namespace lru_tests {
@@ -143,11 +143,11 @@ namespace lru_tests {
  * @tparam T Type of the given message.
  * @returns void
  * */
-template <typename T>
+    template <typename T>
-void log(T msg) {
+    void log(T msg) {
         // It's just to avoid writing cout and endl
         std::cout << "[TESTS] : ---> " << msg << std::endl;
-}
+    }
 
 /**
  * @brief A simple test case
@@ -155,9 +155,9 @@ void log(T msg) {
  * miss
  * @returns void
  * */
-static void test_1() {
+    static void test_1() {
-    int expected_hits = 2;
+        uint64_t expected_hits = 2;
-    int expected_pageFault = 4;
+        uint64_t expected_pageFault = 4;
 
         log("Running Test-1...");
 
@@ -174,7 +174,7 @@ static void test_1() {
                cache.getPageFault() == expected_pageFault);
         log("Assert successful!");
         log("Test-1 complete!");
-}
+    }
 
 /**
  * @brief A test case contains hits more than cache size
@@ -182,9 +182,9 @@ static void test_1() {
  * miss
  * @returns void
  * */
-static void test_2() {
+    static void test_2() {
-    int expected_hits = 4;
+        uint64_t expected_hits = 4;
-    int expected_pageFault = 2;
+        uint64_t expected_pageFault = 2;
 
         log("Running Test-2...");
 
@@ -201,7 +201,7 @@ static void test_2() {
                cache.getPageFault() == expected_pageFault);
         log("Assert successful!");
         log("Test-2 complete!");
-}
+    }
 
 /**
  * @brief A simple test case
@@ -209,9 +209,9 @@ static void test_2() {
  * miss
  * @returns void
  * */
-static void test_3() {
+    static void test_3() {
-    int expected_hits = 1;
+        uint64_t expected_hits = 1;
-    int expected_pageFault = 5;
+        uint64_t expected_pageFault = 5;
 
         log("Running Test-3...");
 
@@ -228,19 +228,19 @@ static void test_3() {
                cache.getPageFault() == expected_pageFault);
         log("Assert successful!");
         log("Test-3 complete!");
-}
+    }
 
 /**
  * @brief A function to invoke all test cases
  * @returns void
  * */
-static void run_tests() {
+    static void run_tests() {
         test_1();
         test_2();
         test_3();
         log("");
         log("TESTS COMPLETED!");
-}
+    }
 }  // namespace lru_tests
 
 /**