semester_tasks

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

@@ -14,8 +14,6 @@ jobs:
 
     - uses: ZedThree/clang-tidy-review@v0.19.0
       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,211 @@
+#pragma once
+
+#include <algorithm>
+#include <iostream>
+#include <memory>
+#include <set>
+#include <type_traits>
+#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;
+};
+
+template <typename T, typename VT>
+concept IsVertex = std::is_base_of<Vertex<VT>, T>::value;
+
+/// @brief Basic graph
+/// @tparam VertexType
+/// @tparam T
+template <typename VertexType, typename T>
+  requires IsVertex<VertexType, T>
+class Graph {
+ public:
+  /**
+   * @brief
+   * Add a new vertex to the graph
+   * @param data
+   */
+  virtual void AddVertex(const T &data) {
+    vertices_.push_back(std::make_shared<VertexType>(data));
+  };
+
+  std::shared_ptr<VertexType> operator[](size_t index) {
+    return vertices_[index];
+  }
+
+  const std::shared_ptr<VertexType> operator[](size_t index) const {
+    return vertices_[index];
+  }
+
+  /**
+   * @brief
+   * Find vertexes index
+   * @param vertex
+   * @return size_t
+   */
+  size_t Find(const T &vertex) const {
+    size_t index;
+    for (index = 0; index < vertices_.size(); ++index)
+      if (vertices_[index]->data == vertex) return index;
+
+    return index;
+  }
+
+  /**
+   * @brief
+   * Remove a vertex from the graph via index
+   * @param vertex_id
+   */
+  virtual void RemoveVertex(size_t vertex_id) {
+    if (vertex_id >= Size()) {
+      // Vertex not found
+      return;
+    }
+
+    // Remove edges pointing to the vertex
+    for (auto &v : vertices_[vertex_id]->adjacent) {
+      RemoveDirEdge(v, vertices_[vertex_id]);
+    }
+
+    // Remove the vertex from the graph
+    vertices_.erase(vertices_.begin() + vertex_id);
+  }
+
+  /**
+   * @brief
+   * Remove a vertex from the graph
+   * @param vertex
+   */
+  virtual void RemoveVertex(std::shared_ptr<VertexType> vertex) {
+    // Find the vertex in the graph
+    auto it = std::find(vertices_.begin(), vertices_.end(), vertex);
+    if (it == vertices_.end()) {
+      // Vertex not found
+      return;
+    }
+
+    RemoveVertex(it - vertices_.begin());
+  }
+
+  /**
+   * @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
+   */
+  virtual 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
+   */
+  virtual void AddDirEdge(std::shared_ptr<VertexType> source,
+                          std::shared_ptr<VertexType> target) {
+    source->adjacent.insert(target);
+  }
+
+  /**
+   * @brief
+   * Remove a directed edge between two vertices via indices
+   * @param source_id
+   * @param target_id
+   */
+  virtual 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
+   */
+  virtual void RemoveDirEdge(std::shared_ptr<VertexType> source,
+                             std::shared_ptr<VertexType> 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
+   */
+  virtual 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
+   */
+  virtual void AddEdge(std::shared_ptr<VertexType> vertex_1,
+                       std::shared_ptr<VertexType> 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
+   */
+  virtual 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
+   */
+  virtual void RemoveEdge(std::shared_ptr<VertexType> vertex_1,
+                          std::shared_ptr<VertexType> vertex_2) {
+    RemoveDirEdge(vertex_1, vertex_2);
+    RemoveDirEdge(vertex_2, vertex_1);
+  }
+
+  /**
+   * @brief
+   * Print the adjacency list of the graph
+   */
+  virtual 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<VertexType>> vertices_;
+};

lib/src/utils.cpp

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

lib/src/weighted_graph.hpp

@@ -0,0 +1,136 @@
+#pragma once
+
+#include <limits>
+
+#include "graph.hpp"
+
+/// @brief Basic weighted graph
+/// @tparam VertexType
+/// @tparam T
+template <typename VertexType, typename T>
+class WeightedGraph : public Graph<VertexType, T> {
+ public:
+  WeightedGraph() : Graph<VertexType, T>() {
+    weights.resize(Graph<VertexType, T>::vertices_.size(),
+                   std::vector<int>(Graph<VertexType, T>::vertices_.size(),
+                                    std::numeric_limits<int>::max()));
+  }
+
+  /**
+   * @brief
+   * Override AddVertex to handle weights matrix resizing
+   * @param data
+   */
+  void AddVertex(const T& data) override {
+    Graph<VertexType, T>::AddVertex(data);
+    weights.resize(Graph<VertexType, T>::vertices_.size(),
+                   std::vector<int>(Graph<VertexType, T>::vertices_.size(),
+                                    std::numeric_limits<int>::max()));
+    for (auto& row : weights)
+      row.resize(Graph<VertexType, T>::vertices_.size(),
+                 std::numeric_limits<int>::max());
+  }
+
+  /**
+   * @brief
+   * Override RemoveVertex via index to handle weights matrix resizing
+   * @param vertex_id
+   */
+  void RemoveVertex(size_t vertex_id) override {
+    // Remove the vertex from the base class
+    Graph<VertexType, T>::RemoveVertex(vertex_id);
+
+    // Remove the corresponding row and column from the weights matrix
+    weights.erase(weights.begin() + vertex_id);  // Remove the row
+
+    for (auto& row : weights)
+      row.erase(row.begin() + vertex_id);  // Remove the column
+  }
+
+  /**
+   * @brief
+   * Add a weighted directed edge
+   * @param source_id
+   * @param target_id
+   * @param weight
+   */
+  void AddDirEdge(size_t source_id, size_t target_id, int weight) {
+    Graph<VertexType, T>::AddDirEdge(source_id, target_id);
+    weights[source_id][target_id] = weight;
+  }
+
+  /**
+   * @brief
+   * Add a weighted undirected edge
+   * @param source_id
+   * @param target_id
+   * @param weight
+   */
+  void AddEdge(size_t source_id, size_t target_id, int weight) {
+    AddDirEdge(source_id, target_id, weight);
+    AddDirEdge(target_id, source_id, weight);
+  }
+
+  /**
+   * @brief
+   * Remove a weighted directed edge
+   * @param source_id
+   * @param target_id
+   */
+  void RemoveDirEdge(size_t source_id, size_t target_id) override {
+    Graph<VertexType, T>::RemoveDirEdge(source_id, target_id);
+    weights[source_id][target_id] = std::numeric_limits<int>::max();
+  }
+
+  /**
+   * @brief
+   * Remove a weighted undirected edge
+   * @param source_id
+   * @param target_id
+   */
+  void RemoveEdge(size_t source_id, size_t target_id) override {
+    RemoveDirEdge(source_id, target_id);
+    RemoveDirEdge(target_id, source_id);
+  }
+
+  /**
+   * @brief
+   * Get the weight of an edge
+   * @param source_id
+   * @param target_id
+   * @return int
+   */
+  int GetWeight(size_t source_id, size_t target_id) const {
+    return weights[source_id][target_id];
+  }
+
+  /**
+   * @brief
+   * Reweight an edge
+   * @param source_id
+   * @param target_id
+   * @param new_weight
+   */
+  void Reweight(size_t source_id, size_t target_id, int new_weight) {
+    weights[source_id][target_id] = new_weight;
+  }
+
+  /**
+   * @brief
+   * Print the weighted graph
+   */
+  void PrintGraph() const override {
+    for (size_t i = 0; i < Graph<VertexType, T>::vertices_.size(); ++i) {
+      std::cout << Graph<VertexType, T>::vertices_[i]->data << " -> ";
+      for (const auto& neighbor :
+           Graph<VertexType, T>::vertices_[i]->adjacent) {
+        size_t j = Graph<VertexType, T>::Find(neighbor->data);
+        std::cout << "(" << neighbor->data << ", " << weights[i][j] << ") ";
+      }
+      std::cout << std::endl;
+    }
+  }
+
+ private:
+  std::vector<std::vector<int>> weights;
+};

task_01/src/main.cpp

@@ -1 +1,25 @@
-int main() { return 0; }
+#include "packman.hpp"
+
+int main() {
+  DependencyGraph dg;
+
+  std::vector<std::string> packages = {"Lib_1", "Lib_2", "Lib_3", "Lib_4",
+                                       "Lib_5"};
+  for (const auto& package : packages) dg.AddVertex(package);
+
+  dg.AddDirEdge(0, 1);  // Lib_1 depends on Lib_2
+  dg.AddDirEdge(0, 2);  // Lib_1 depends on Lib_3
+  dg.AddDirEdge(2, 3);  // Lib_3 depends on Lib_4
+  dg.AddDirEdge(3, 1);  // Lib_4 depends on Lib_2
+  dg.AddDirEdge(0, 3);  // Lib_1 depends on Lib_4
+
+  PackageManager packman(dg);
+
+  packman.FindDownloadingOrder("Lib_1");
+  packman.FindDownloadingOrder("Lib_2");
+  packman.FindDownloadingOrder("Lib_3");
+  packman.FindDownloadingOrder("Lib_4");
+  packman.FindDownloadingOrder("Lib_5");
+
+  return 0;
+}