Add task 11.06

Author: c71n93

week-12/CMakeLists.txt

@@ -1,4 +1,4 @@
-set(DIRS task-11-01 task-11-03)
+set(DIRS task-11-01 task-11-03 task-11-06)
 foreach(DIR ${DIRS})
     add_subdirectory(${DIR})
 endforeach()

week-12/task-11-06/CMakeLists.txt

@@ -0,0 +1,3 @@
+include_directories(include)
+
+add_subdirectory(test)

week-12/task-11-06/include/circle.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <numbers>
+#include "ivisitor.hpp"
+#include "shape.hpp"
+
+namespace geometry2d {
+
+class Circle : public Shape {
+public:
+    static constexpr double pi = std::numbers::pi;
+
+    explicit Circle(double r) : radius_(r) {
+        if (radius_ <= 0) {
+            throw std::invalid_argument("Radius must be positive.");
+        }
+    }
+
+    double radius() const { return radius_; }
+
+    double perimeter() const override {
+        return 2 * pi * radius_;
+    }
+    double area() const override {
+        return pi * radius_ * radius_;
+    }
+
+    void visit_by(const IVisitor& visitor) const override {
+        visitor.visit(*this);
+    }
+
+private:
+    double radius_;
+};
+
+}  // namespace geometry2d

week-12/task-11-06/include/ivisitor.hpp

@@ -0,0 +1,19 @@
+#pragma once
+
+namespace geometry2d {
+
+class Circle;
+class Square;
+class Triangle;
+class Shape;
+
+class IVisitor {
+public:
+    virtual ~IVisitor() = default;
+
+    virtual void visit(const Circle& c) const = 0;
+    virtual void visit(const Square& s) const = 0;
+    virtual void visit(const Triangle& t) const = 0;
+};
+
+}  // namespace geometry2d

week-12/task-11-06/include/serializer.hpp

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <iostream>
+
+#include "ivisitor.hpp"
+#include "circle.hpp"
+#include "square.hpp"
+#include "triangle.hpp"
+
+namespace geometry2d {
+
+class Serializer : public IVisitor {
+public:
+    void visit(const Circle &c) const override {
+        std::cout << "Circle:" << std::endl;
+        std::cout << "\tradius: " << c.radius() << std::endl;
+        std::cout << "\t\tperimeter: " << c.perimeter() << std::endl;
+        std::cout << "\t\tarea: " << c.area() << std::endl;
+    }
+    void visit(const Square &s) const override {
+        std::cout << "Square:" << std::endl;
+        std::cout << "\tside: " << s.side() << std::endl;
+        std::cout << "\t\tperimeter: " << s.perimeter() << std::endl;
+        std::cout << "\t\tarea: " << s.area() << std::endl;
+    }
+    void visit(const Triangle &t) const override {
+        std::cout << "Triangle:" << std::endl;
+        std::cout << "\tside1: " << t.side1() << std::endl;
+        std::cout << "\tside2: " << t.side2() << std::endl;
+        std::cout << "\tside3: " << t.side3() << std::endl;
+        std::cout << "\t\tperimeter: " << t.perimeter() << std::endl;
+        std::cout << "\t\tarea: " << t.area() << std::endl;
+    }
+};
+
+}  // namespace geometry2d

week-12/task-11-06/include/shape.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+namespace geometry2d {
+
+#include "ivisitor.hpp"
+
+class Shape {
+public:
+    virtual ~Shape() = default;
+
+    virtual void visit_by(const IVisitor& visitor) const = 0;
+    virtual double perimeter() const = 0;
+    virtual double area() const = 0;
+};
+
+}  // namespace geometry2d

week-12/task-11-06/include/square.hpp

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "ivisitor.hpp"
+#include "shape.hpp"
+
+namespace geometry2d {
+
+class Square : public Shape {
+public:
+    explicit Square(double s) : side_(s) {
+        if (side_ <= 0) {
+            throw std::invalid_argument("Side must be positive.");
+        }
+    }
+
+    double side() const { return side_; }
+
+    double perimeter() const override {
+        return 4 * side_;
+    }
+    double area() const override {
+        return side_ * side_;
+    }
+
+    void visit_by(const IVisitor& visitor) const override {
+        visitor.visit(*this);
+    }
+
+private:
+    double side_;
+};
+
+}  // namespace geometry2d

week-12/task-11-06/include/triangle.hpp

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <cmath>
+
+#include "shape.hpp"
+
+namespace geometry2d {
+
+class Triangle : public Shape {
+public:
+    Triangle(double s1, double s2, double s3) : side1_(s1), side2_(s2), side3_(s3) {
+        if (side1_ <= 0 || side2_ <= 0 || side3_ <= 0) {
+            throw std::invalid_argument("All sides must be positive.");
+        }
+        if (side1_ + side2_ <= side3_ || side1_ + side3_ <= side2_ || side2_ + side3_ <= side1_) {
+            throw std::invalid_argument("Invalid triangle sides.");
+        }
+    }
+
+    double side1() const { return side1_; }
+    double side2() const { return side2_; }
+    double side3() const { return side3_; }
+
+    double perimeter() const override {
+        return side1_ + side2_ + side3_;
+    }
+    double area() const override {
+        const double p = perimeter() / 2;
+        return std::sqrt(p * (p - side1_) * (p - side2_) * (p - side3_));
+    }
+
+    void visit_by(const IVisitor& visitor) const override {
+        visitor.visit(*this);
+    }
+
+private:
+    double side1_, side2_, side3_;
+};
+
+}  // namespace geometry2d

week-12/task-11-06/test/CMakeLists.txt

@@ -0,0 +1 @@
+cpp_test(test-11-06.cpp)

week-12/task-11-06/test/test-11-06.cpp

@@ -0,0 +1,68 @@
+#include <gtest/gtest.h>
+
+#include <iostream>
+#include <memory>
+#include <sstream>
+
+#include "serializer.hpp"
+
+using geometry2d::Circle;
+using geometry2d::Serializer;
+using geometry2d::Shape;
+using geometry2d::Square;
+using geometry2d::Triangle;
+
+std::string capture_output(const std::function<void()>& printer_func) {
+    const std::ostringstream oss;
+    auto old_cout_buffer = std::cout.rdbuf(oss.rdbuf());
+    printer_func();
+    std::cout.rdbuf(old_cout_buffer);
+    return oss.str();
+}
+
+TEST(Serializer, ShapeCircle) {
+    const Serializer serializer{};
+    const std::unique_ptr<Shape> shape = std::make_unique<Circle>(4);
+    const std::string expected_output =
+        "Circle:\n"
+        "\tradius: 4\n"
+        "\t\tperimeter: 25.1327\n"
+        "\t\tarea: 50.2655\n";
+    const std::string output = capture_output([&]() { shape->visit_by(serializer); });
+    EXPECT_EQ(output, expected_output);
+}
+
+TEST(Serializer, ShapeSquare) {
+    const Serializer serializer{};
+    const std::unique_ptr<Shape> shape = std::make_unique<Square>(5);
+    const std::string expected_output =
+        "Square:\n"
+        "\tside: 5\n"
+        "\t\tperimeter: 20\n"
+        "\t\tarea: 25\n";
+    const std::string output = capture_output([&]() { shape->visit_by(serializer); });
+    EXPECT_EQ(output, expected_output);
+}
+
+TEST(Serializer, ShapeTriangle) {
+    const Serializer serializer{};
+    const std::unique_ptr<Shape> shape = std::make_unique<Triangle>(3, 4, 5);
+    const std::string expected_output =
+        "Triangle:\n"
+        "\tside1: 3\n"
+        "\tside2: 4\n"
+        "\tside3: 5\n"
+        "\t\tperimeter: 12\n"
+        "\t\tarea: 6\n";
+    const std::string output = capture_output([&]() { shape->visit_by(serializer); });
+    EXPECT_EQ(output, expected_output);
+}
+
+TEST(Serializer, InvalidCircleRadius) { EXPECT_THROW(Circle(-1), std::invalid_argument); }
+
+TEST(Serializer, InvalidSquareSide) { EXPECT_THROW(Square(0), std::invalid_argument); }
+
+TEST(Serializer, InvalidTriangleSides) {
+    EXPECT_THROW(Triangle(1, 2, 3), std::invalid_argument);
+    EXPECT_THROW(Triangle(-1, 2, 2), std::invalid_argument);
+}