Dev #1

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Closed

mohameds-dev wants to merge 46 commits into main from dev

.github/workflows/cmake.yml

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -18,5 +18,5 @@ jobs:
  
          - name: Build and test

            run: |

              chmod +x build.sh

              ./build.sh

              chmod +x run_build.sh

              ./run_build.sh

CMakeLists.txt

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -1,12 +1,12 @@
  
    cmake_minimum_required(VERSION 3.10)

    project(MyProject LANGUAGES CXX)

    project(ordered_map LANGUAGES CXX)

    set(CMAKE_CXX_STANDARD 17)

    set(CMAKE_CXX_STANDARD_REQUIRED ON)

    # Add source files

    add_library(myproject src/doubly_linked_list.cpp)

    target_include_directories(myproject PUBLIC include)

    add_library(ordered_map src/doubly_linked_list.cpp)

    target_include_directories(ordered_map PUBLIC include)

    # Enable testing

    enable_testing()

    @@ -21,8 +21,22 @@ FetchContent_Declare(
  
    FetchContent_MakeAvailable(catch2)

    # Add test executable

    add_executable(tests tests/test_doubly_linked_list.cpp)

    target_link_libraries(tests PRIVATE myproject Catch2::Catch2WithMain)

    add_executable(

      tests

      tests/doubly_linked_list/size_tests.cpp

      tests/doubly_linked_list/front_and_back.cpp

      tests/doubly_linked_list/iterator_tests.cpp

      tests/doubly_linked_list/pop_back_tests.cpp

      tests/doubly_linked_list/pop_front_tests.cpp

      tests/doubly_linked_list/push_back_tests.cpp

      tests/doubly_linked_list/push_front_tests.cpp

      tests/doubly_linked_list/clear_tests.cpp

      tests/ordered_map/size_tests.cpp

      tests/ordered_map/insertion_tests.cpp

      tests/ordered_map/lookup_tests.cpp

      tests/ordered_map/iterator_tests.cpp

    )

    target_link_libraries(tests PRIVATE ordered_map Catch2::Catch2WithMain)

    # Register tests

    include(CTest)

README.md

            
                      Original file line number
                      Diff line number
                      Diff line change
                  
    @@ -3,6 +3,7 @@
  
    A C++ project implementing an ordered map using a doubly-linked list to maintain element insertion order, built with CMake, tested with Catch2, and formatted with Clang-Format.

    ## Table of Contents

    - [Prerequisites](#prerequisites)

    - [Project Structure](#project-structure)

    - [Setting Up VS Code (or Cursor)](#setting-up-vs-code-or-cursor)

    @@ -11,7 +12,7 @@ A C++ project implementing an ordered map using a doubly-linked list to maintain
  
    - [GitHub Actions CI](#github-actions-ci)

    - [Adding a New Test](#adding-a-new-test)

    - [Troubleshooting](#troubleshooting)

    - [Example Test File](#example-test-file)

    - [Project Status](#project-status)

    ## Prerequisites

    @@ -22,6 +23,7 @@ A C++ project implementing an ordered map using a doubly-linked list to maintain
  
    - **VS Code** or **Cursor**: Code editor with C++ support

    Verify installations:

    ```bash

    cmake --version

    git --version

    @@ -40,22 +42,30 @@ ordered_map/
  
    ├── build.sh              # Script to build and test

    ├── .clang-format         # Code formatting rules

    ├── include/

    │   └── ordered_map.hpp    # Ordered map interface

    │   ├── doubly_linked_list.hpp    # Doubly-linked list implementation

    │   └── ordered_map.hpp          # (Future) Ordered map interface

    ├── src/

    │   └── doubly_linked_list.cpp  # Doubly-linked list implementation

    ├── tests/

    │   └── test_ordered_map.cpp  # Catch2 test files

    │   └── doubly_linked_list/      # Test files for doubly linked list

    │       ├── front_and_back.cpp   # Tests for front/back operations

    │       ├── iterator_tests.cpp   # Tests for iterator functionality

    │       ├── pop_back_tests.cpp   # Tests for pop_back operations

    │       ├── pop_front_tests.cpp  # Tests for pop_front operations

    │       ├── push_back_tests.cpp  # Tests for push_back operations

    │       └── push_front_tests.cpp # Tests for push_front operations

    ```

    ## Setting Up VS Code (or Cursor)

    1. **Install Extensions**:

       - In VS Code/Cursor, go to Extensions (Ctrl+Shift+X).

       - Install:

         - **C/C++** (Microsoft): For IntelliSense and debugging.

         - **CMake Tools** (Microsoft): For CMake integration.

    2. **Configure IntelliSense**:

       - Create `.vscode/settings.json` (or `.cursor/settings.json`):

         ```json

         {

    @@ -85,13 +95,16 @@ ordered_map/
  
    ## Building and Running Tests

    1. **Build and Test**:

       ```bash

       chmod +x build.sh

       ./build.sh

       ```

       - Formats code, builds with CMake/make, and runs Catch2 tests.

    2. **Output**:

       - Successful tests show:

         ```

         All tests passed (X assertions in Y test cases)

    @@ -100,7 +113,7 @@ ordered_map/
  
    3. **Run Specific Tests**:

       ```bash

       cd build

       ./tests --tags [canary]

       ./tests --tags [tag]

       ```

    ## GitHub Actions CI

    @@ -111,22 +124,30 @@ ordered_map/
  
      2. Ensure `.github/workflows/cmake.yml` exists.

      3. CI runs `build.sh` on `ubuntu-latest`, formatting, building, and testing.

    - **View Results**:

      - Check the “Actions” tab on GitHub for CI logs.

      - Check the "Actions" tab on GitHub for CI logs.

    ## Adding a New Test

    1. **Edit `tests/test_ordered_map.cpp`**:

       - Add a `TEST_CASE` for the ordered map or doubly-linked list. Example:

         ```cpp

         TEST_CASE("Insert maintains order", "[ordered_map]") {

             OrderedMap<int, int> map;

             map.insert(1, 10);

             map.insert(2, 20);

             REQUIRE(map.size() == 2);

         }

         ```

    1. **Choose the appropriate test file** in `tests/doubly_linked_list/` based on the functionality being tested:

    2. **Rebuild and Test**:

       - `front_and_back.cpp` for front/back operations

       - `iterator_tests.cpp` for iterator functionality

       - `pop_back_tests.cpp` for pop_back operations

       - `pop_front_tests.cpp` for pop_front operations

       - `push_back_tests.cpp` for push_back operations

       - `push_front_tests.cpp` for push_front operations

    2. **Add your test case**:

       ```cpp

       TEST_CASE("Your test description", "[tag]") {

           DoublyLinkedList<int> list;

           // Your test code here

           REQUIRE(/* your assertion */);

       }

       ```

    3. **Rebuild and Test**:

       ```bash

       ./build.sh

       ```

    @@ -140,27 +161,32 @@ ordered_map/
  
      - Clear build: `rm -rf build && ./build.sh`.

      - Check prerequisites.

    - **Test Failures**:

      - Inspect assertions in `test_ordered_map.cpp`.

      - Inspect assertions in the relevant test file.

      - Run specific tests: `./build/tests --tags [tag]`.

    - **GitHub Actions Failures**:

      - Check logs in the “Actions” tab on GitHub.

      - Check logs in the "Actions" tab on GitHub.

      - Ensure `build.sh` and dependencies are compatible with `ubuntu-latest`.

    ## Example Test File

    ## Project Status

    `tests/test_ordered_map.cpp`:

    ```cpp

    #include <catch2/catch_test_macros.hpp>

    #include "ordered_map.hpp"

    The project is currently in development, with the following components:

    TEST_CASE("Canary test", "[canary]") {

        REQUIRE(true);

    }

    1. ✅ Doubly Linked List Implementation

    TEST_CASE("Insert maintains order", "[ordered_map]") {

        OrderedMap<int, int> map;

        map.insert(1, 10);

        map.insert(2, 20);

        REQUIRE(map.size() == 2);

    }

    ```

       - Basic operations (push_back, pop_back, push_front, pop_front)

       - Memory management using smart pointers

       - Comprehensive test coverage organized by functionality

       - Iterator support (basic implementation)

    2. 🔄 Ordered Map Implementation (Coming Soon)

       - Will use the doubly linked list as its underlying data structure

       - Will maintain insertion order while providing map-like functionality

    ### Checklist for future improvements

    - [ ] DoublyLinkedList: Add tests for copying & moving

    - [ ] DoublyLinkedList: Add `erase` method to erase elements given their iterator

    - [ ] DoublyLinkedList: Add pre and post decrement operators

    - [ ] DoublyLinkedList: Test front(), back(), insertion and deletion functions for copying behavior

    - [ ] DoublyLinkedList: Test front(), back(), insertion and deletion functions for destructor behavior

include/doubly_linked_list.hpp

-Original file line number
+Diff line change
@@ -0,0 +1,169 @@
+    #pragma once
+    #include <memory>
+    template <typename T>
+    struct Node {
+        T value;
+        std::unique_ptr<Node> next;
+        Node* prev;
+        Node(const T& a_value, Node* a_prev, std::unique_ptr<Node> a_next)
+            : value(a_value), prev(a_prev), next(std::move(a_next)) {}
+    };
+    template <typename T>
+    class DoublyLinkedList {
+    private:
+        std::unique_ptr<Node<T>> head;
+        Node<T>* tail;
+        int _size;
+    public:
+        DoublyLinkedList() : head(nullptr), tail(nullptr), _size(0) {}
+        ~DoublyLinkedList() {
+            clear();
+        }
+        int size() const {
+            return _size;
+        }
+        const T& front() const {
+            if (!head) {
+                throw std::out_of_range("List is empty");
+            }
+            return head->value;
+        }
+        const T& back() const {
+            if (!tail) {
+                throw std::out_of_range("List is empty");
+            }
+            return tail->value;
+        }
+        void push_back(const T& value) {
+            if (!head) {
+                head = std::make_unique<Node<T>>(value, nullptr, nullptr);
+                tail = head.get();
+            } else {
+                tail->next = std::make_unique<Node<T>>(value, tail, nullptr);
+                tail = tail->next.get();
+            }
+            _size++;
+        }
+        T pop_back() {
+            if (!head) {
+                throw std::out_of_range("List is empty");
+            }
+            T popped_value = tail->value;
+            if (tail == head.get()) {
+                head.reset();
+                tail = nullptr;
+            } else {
+                Node<T>* prev_node = tail->prev;
+                prev_node->next.reset();
+                tail = prev_node;
+            }
+            _size--;
+            return popped_value;
+        }
+        void push_front(const T& value) {
+            if (!head) {
+                head = std::make_unique<Node<T>>(value, nullptr, nullptr);
+                tail = head.get();
+            } else {
+                auto new_node = std::make_unique<Node<T>>(value, nullptr, std::move(head));
+                new_node->next->prev = new_node.get();
+                head = std::move(new_node);
+            }
+            _size++;
+        }
+        T pop_front() {
+            if (!head) {
+                throw std::out_of_range("List is empty");
+            }
+            T popped_value = head->value;
+            head = std::move(head->next);
+            if (!head)
+                tail = nullptr;
+            _size--;
+            return popped_value;
+        }
+        void clear() {
+            while(size() > 0) {
+                pop_back();
+            }
+        }
+        bool empty() const {
+            return _size == 0;
+        }
+        class Iterator {
+            Node<T>* current_node_ptr;
+            Iterator(Node<T>* a_current) : current_node_ptr(a_current) {}
+            friend class DoublyLinkedList<T>;
+        public:
+            Iterator() : current_node_ptr(nullptr) {}
+            bool operator==(const Iterator& other) const {
+                return current_node_ptr == other.current_node_ptr;
+            }
+            bool operator!=(const Iterator& other) const {
+                return current_node_ptr != other.current_node_ptr;
+            }
+            T& operator*() const {
+                return current_node_ptr->value;
+            }
+            Iterator& operator++() {
+                if (current_node_ptr) {
+                    current_node_ptr = current_node_ptr->next.get();
+                }
+                return *this;
+            }
+            Iterator operator++(int) {
+                Iterator initial_state_copy = *this;
+                ++(*this);
+                return initial_state_copy;
+            }
+            Iterator& operator--() {
+                if (current_node_ptr) {
+                    current_node_ptr = current_node_ptr->prev;
+                }
+                return *this;
+            }
+        };
+        Iterator begin() {
+            return Iterator(head.get());
+        }
+        Iterator end() {
+            return Iterator(nullptr);
+        }
+        Iterator back_iterator() {
+            return Iterator(tail);
+        }
+    };

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Dev #1

Uh oh!

Diff view

Diff view

There are no files selected for viewing

Uh oh!

Uh oh!