semester_tasks

.github/workflows/clang-tidy-review.yaml

@@ -14,8 +14,6 @@ jobs:
 
     - uses: ZedThree/[email protected]
       with:
-        apt_packages: libgtest-dev
-        clang_tidy_version: 18
         clang_tidy_checks: '-*,performance-*,bugprone-*,clang-analyzer-*,cppcoreguidelines-*,mpi-*,misc-*,-cppcoreguidelines-avoid-non-const-global-variables,-cppcoreguidelines-avoid-magic-numbers,-clang-diagnostic-error,-misc-no-recursion,-cppcoreguidelines-owning-memory,-bugprone-narrowing-conversions,-bugprone-easily-swappable-parameters,-misc-non-private-member-variables-in-classes,-cppcoreguidelines-pro-bounds-pointer-arithmetic,-cppcoreguidelines-special-member-functions,-cppcoreguidelines-init-variables,-misc-include-cleaner'
         split_workflow: true
 

lib/src/graph.hpp

@@ -0,0 +1,187 @@
+#pragma once
+
+#include <algorithm>
+#include <iostream>
+#include <memory>
+#include <set>
+#include <vector>
+
+/// @brief Graphs vertex
+/// @tparam T
+template <typename T>
+struct Vertex {
+  Vertex(const T &d) : data(d) {}
+
+  T data;
+  std::set<std::shared_ptr<Vertex<T>>> adjacent;
+};
+
+/// @brief Basic graph
+/// @tparam T
+template <typename T>
+class Graph {
+ public:
+  /**
+   * @brief
+   * Add a new vertex to the graph
+   * @param data
+   */
+  void AddVertex(const T &data) {
+    vertices_.push_back(std::make_shared<Vertex<T>>(data));
+  };
+
+  std::shared_ptr<Vertex<T>> operator[](size_t index) {
+    return vertices_[index];
+  }
+
+  const std::shared_ptr<Vertex<T>> operator[](size_t index) const {
+    return vertices_[index];
+  }
+
+  /**
+   * @brief
+   * Find vertexes index
+   * @param vertex
+   * @return size_t
+   */
+  size_t Find(const std::shared_ptr<Vertex<T>> &vertex) const {
+    return std::find(vertices_.begin(), vertices_.end(), vertex) -
+           vertices_.begin();
+  };
+
+  /**
+   * @brief
+   * Remove a vertex from the graph
+   * @param vertex
+   */
+  void RemoveVertex(std::shared_ptr<Vertex<T>> vertex) {
+    // Find the vertex in the graph
+    auto it = std::find(vertices_.begin(), vertices_.end(), vertex);
+    if (it == vertices_.end()) {
+      // Vertex not found
+      return;
+    }
+
+    // Remove edges pointing to the vertex
+    for (auto &v : vertices_[it - vertices_.begin()]->adjacent) {
+      RemoveEdge(v, vertices_[it - vertices_.begin()]);
+    }
+    // Remove the vertex from the graph
+    vertices_.erase(it);
+  }
+
+  /**
+   * @brief
+   * Returns the number of vertices in the graph
+   * @return size_t
+   */
+  size_t Size() const { return vertices_.size(); }
+
+  /**
+   * @brief
+   * Add a directed edge between two vertices via indices
+   * @param source_id
+   * @param target_id
+   */
+  void AddDirEdge(size_t source_id, size_t target_id) {
+    operator[](source_id)->adjacent.insert(operator[](target_id));
+  }
+
+  /**
+   * @brief
+   * Add a directed edge between two vertices
+   * @param source
+   * @param target
+   */
+  void AddDirEdge(std::shared_ptr<Vertex<T>> source,
+                  std::shared_ptr<Vertex<T>> target) {
+    source->adjacent.insert(target);
+  }
+
+  /**
+   * @brief
+   * Remove a directed edge between two vertices via indices
+   * @param source_id
+   * @param target_id
+   */
+  void RemoveDirEdge(size_t source_id, size_t target_id) {
+    operator[](source_id)->adjacent.erase(*std::find(
+        operator[](source_id)->adjacent.begin(),
+        operator[](source_id)->adjacent.end(), operator[](target_id)));
+  }
+
+  /**
+   * @brief
+   * Remove a directed edge between two vertices
+   * @param source
+   * @param target
+   */
+  void RemoveDirEdge(std::shared_ptr<Vertex<T>> source,
+                     std::shared_ptr<Vertex<T>> target) {
+    source->adjacent.erase(
+        *std::find(source->adjacent.begin(), source->adjacent.end(), target));
+  }
+
+  /**
+   * @brief
+   * Add a non-directed edge between two vertices via indices
+   * @param first_id
+   * @param second_id
+   */
+  void AddEdge(size_t first_id, size_t second_id) {
+    AddDirEdge(first_id, second_id);
+    AddDirEdge(second_id, first_id);
+  }
+
+  /**
+   * @brief
+   * Add a non-directed edge between two vertices
+   * @param vertex_1
+   * @param vertex_2
+   */
+  void AddEdge(std::shared_ptr<Vertex<T>> vertex_1,
+               std::shared_ptr<Vertex<T>> vertex_2) {
+    AddDirEdge(vertex_1, vertex_2);
+    AddDirEdge(vertex_2, vertex_1);
+  }
+
+  /**
+   * @brief
+   * Remove a non-directed edge between two vertices via indices
+   * @param first_id
+   * @param second_id
+   */
+  void RemoveEdge(size_t first_id, size_t second_id) {
+    RemoveDirEdge(first_id, second_id);
+    RemoveDirEdge(second_id, first_id);
+  }
+
+  /**
+   * @brief
+   * Remove a non-directed edge between two vertices
+   * @param vertex_1
+   * @param vertex_2
+   */
+  void RemoveEdge(std::shared_ptr<Vertex<T>> vertex_1,
+                  std::shared_ptr<Vertex<T>> vertex_2) {
+    RemoveDirEdge(vertex_1, vertex_2);
+    RemoveDirEdge(vertex_2, vertex_1);
+  }
+
+  /**
+   * @brief
+   * Print the adjacency list of the graph
+   */
+  void PrintGraph() const {
+    for (const auto &vertex : vertices_) {
+      std::cout << vertex->data << " -> ";
+      for (const auto &neighbor : vertex->adjacent) {
+        std::cout << neighbor->data << " ";
+      }
+      std::cout << std::endl;
+    }
+  }
+
+ protected:
+  std::vector<std::shared_ptr<Vertex<T>>> vertices_;
+};

lib/src/utils.cpp

@@ -0,0 +1 @@
+#include "utils.hpp"

task_01/src/main.cpp

@@ -1 +1,23 @@
-int main() { return 0; }
+#include "packman.hpp"
+
+int main() {
+  DependencyGraph dg_1;
+
+  dg_1.AddVertex("Lib_1");
+  dg_1.AddVertex("Lib_2");
+  dg_1.AddVertex("Lib_3");
+  dg_1.AddVertex("Lib_4");
+  dg_1.AddVertex("Lib_5");
+
+  dg_1.AddDirEdge(0, 1);
+  dg_1.AddDirEdge(0, 2);
+  dg_1.AddDirEdge(2, 3);
+  dg_1.AddDirEdge(3, 1);
+  dg_1.AddDirEdge(0, 3);
+
+  PackageManager packman_1(dg_1);
+
+  packman_1.FindDownloadingOrder();
+
+  return 0;
+}

task_01/src/packman.cpp

@@ -0,0 +1,35 @@
+#include "packman.hpp"
+
+void PackageManager::FindingOrderStep(
+    std::shared_ptr<Vertex<std::string>> target) {
+  is_visited_[dependencies_.Find(target)] = true;
+
+  for (auto& neighbor : target->adjacent) {
+    if (!is_visited_[dependencies_.Find(neighbor)]) {
+      FindingOrderStep(neighbor);
+    }
+  }
+
+  reverse_order_.push(target->data);
+}
+
+std::vector<std::string> PackageManager::FindDownloadingOrder(/*
+    std::shared_ptr<Vertex<std::string>> target*/) {
+  is_visited_.resize(dependencies_.Size());
+  for (size_t i = 0; i < is_visited_.size(); ++i) is_visited_[i] = false;
+
+  for (size_t i = 0; i < dependencies_.Size(); ++i)
+    if (!is_visited_[i]) FindingOrderStep(dependencies_[i]);
+
+  std::vector<std::string> order;
+
+  std::cout << "Downloading Order for "
+            << /*target->data <<*/ " is:" << std::endl;
+  while (reverse_order_.size() > 0) {
+    order.push_back(reverse_order_.top());
+    std::cout << reverse_order_.top() << " ";
+    reverse_order_.pop();
+  }
+  std::cout << std::endl;
+  return order;
+}

task_01/src/packman.hpp

@@ -0,0 +1,31 @@
+#include <stack>
+#include <string>
+
+#include "graph.hpp"
+
+/// @brief Graph of dependencies between libraries
+/// The "parent" libraries should be installed before thier children
+class DependencyGraph : public Graph<std::string> {};
+
+/// @brief Packman basic algorithm
+class PackageManager {
+ public:
+  PackageManager() = delete;
+  PackageManager(DependencyGraph& dep_graph) : dependencies_{dep_graph} {}
+
+  /**
+   * @brief
+   * Finds the right order to install libraries in
+   * with respect to dependencies
+   * @param target Needed library
+   * @return std::vector<std::string>
+   */
+  std::vector<std::string> FindDownloadingOrder(/*
+      std::shared_ptr<Vertex<std::string>> target*/);
+
+ private:
+  void FindingOrderStep(std::shared_ptr<Vertex<std::string>> target);
+  DependencyGraph& dependencies_;
+  std::vector<bool> is_visited_;
+  std::stack<std::string> reverse_order_;
+};