some more thoughts for refactoring

CMakeLists.txt

@@ -39,6 +39,7 @@ set_property(TARGET ${PROJECT_NAME} APPEND PROPERTY
 )
 
 target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src)
+target_include_directories(${PROJECT_NAME} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/src2)
 
 add_subdirectory(src)
 add_subdirectory(src2)

src2/CMakeLists.txt

@@ -1,11 +1,13 @@
 set(SOURCES
-    component.cpp
     collection.cpp
+    loggable.cpp
 )
 
 set(HEADERS
-    component.h
     collection.h
+    loggable.h
 )
 
 target_sources(${PROJECT_NAME} PRIVATE ${SOURCES})
+
+add_subdirectory(components)

src2/component.cpp

@@ -1 +0,0 @@
-#include "component.h"

src2/component.h

@@ -1,40 +0,0 @@
-#pragma once
-
-#include <string>
-#include <filesystem>
-
-#include "loggger.h"
-#include "collection.h"
-
-class Component {
-public:
-    enum State {
-        initial,
-        reading,
-        building,
-        ready
-    };
-
-    enum Type {
-        unknown,
-        file,
-        directory,
-        mason
-    };
-
-    Component(Logger* logger, Collection* collection);
-    virtual ~Component();
-
-    Type getType() const;
-    Type getState() const;
-
-    virtual void read(const std::filesystem::path& path) = 0;
-    virtual void build(const std::filesystem::path& destination, const std::string& target) = 0;
-
-protected:
-    State state;
-    Type type;
-    Logger* logger;
-    Collection* collection;
-    std::filesystem::path location;
-};

src2/components/CMakeLists.txt

@@ -0,0 +1,11 @@
+set(SOURCES
+    component.cpp
+    file.cpp
+)
+
+set(HEADERS
+    component.h
+    file.h
+)
+
+target_sources(${PROJECT_NAME} PRIVATE ${SOURCES})

src2/components/component.cpp

@@ -0,0 +1,23 @@
+#include "component.h"
+
+Component::Component(const std::shared_ptr<Collection>& collection, const std::shared_ptr<Logger>& logger):
+    Loggable(logger),
+    collection(collection)
+{}
+
+void Component::read(const std::filesystem::path& path) {
+    if (state != initial)
+        throw WrongState(state, "read");
+
+    location = path;
+    state = reading;
+}
+
+
+Component::State Component::getState() const {
+    return state;
+}
+
+Component::Type Component::getType() const {
+    return type;
+}

src2/components/component.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#include <string>
+#include <filesystem>
+#include <memory>
+#include <exception>
+
+#include "loggable.h"
+#include "loggger.h"
+#include "collection.h"
+
+class Component : protected Loggable {
+public:
+    class WrongState;
+    enum State {
+        initial,
+        reading,
+        building,
+        ready
+    };
+
+    enum Type {
+        unknown,
+        file,
+        directory,
+        mason
+    };
+
+    Component(const std::shared_ptr<Collection>& collection, const std::shared_ptr<Logger>& logger);
+    virtual ~Component() override = default;
+
+    Type getType() const;
+    State getState() const;
+
+    virtual void read(const std::filesystem::path& path);
+    virtual void build(const std::filesystem::path& destination, const std::string& target) = 0;
+
+protected:
+    State state;
+    Type type;
+    std::shared_ptr<Collection> collection;
+    std::filesystem::path location;
+};
+
+class Component::WrongState : public std::exception {
+public:
+    WrongState(State state, const std::string& action);
+
+    const char* what() const noexcept( true ) override;
+private:
+    State state;
+    std::string action;
+};

src2/components/file.cpp

@@ -0,0 +1 @@
+#include "file.h"

src2/components/file.h

@@ -0,0 +1,14 @@
+#pragma once
+
+#include <filesystem>
+#include <memory>
+
+#include "component.h"
+
+class File : public Component {
+public:
+    File(const std::shared_ptr<Collection>& collection, const std::shared_ptr<Logger>& logger);
+
+protected:
+
+};

src2/loggable.cpp

@@ -0,0 +1,37 @@
+#include "loggable.h"
+
+Loggable::Loggable(const std::shared_ptr<Logger>& logger):
+    logger(logger)
+{}
+
+void Loggable::log(Logger::Severity severity, const std::string& message) const {
+    logger->log(severity, message);
+}
+
+void Loggable::debug(const std::string& message) const {
+    log(Logger::Severity::debug, message);
+}
+
+void Loggable::info(const std::string& message) const {
+    log(Logger::Severity::info, message);
+}
+
+void Loggable::minor(const std::string& message) const {
+    log(Logger::Severity::minor, message);
+}
+
+void Loggable::major(const std::string& message) const {
+    log(Logger::Severity::major, message);
+}
+
+void Loggable::warn(const std::string& message) const {
+    log(Logger::Severity::warning, message);
+}
+
+void Loggable::error(const std::string& message) const {
+    log(Logger::Severity::error, message);
+}
+
+void Loggable::fatal(const std::string& message) const {
+    log(Logger::Severity::fatal, message);
+}

src2/loggable.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <memory>
+
+#include "loggger.h"
+
+class Loggable {
+public:
+    explicit Loggable(const std::shared_ptr<Logger>& logger);
+    virtual ~Loggable() = default;
+
+    void debug(const std::string& message) const;
+    void info(const std::string& message) const;
+    void minor(const std::string& message) const;
+    void major(const std::string& message) const;
+    void warn(const std::string& message) const;
+    void error(const std::string& message) const;
+    void fatal(const std::string& message) const;
+
+private:
+    void log(Logger::Severity severity, const std::string& message) const;
+
+private:
+    std::shared_ptr<Logger> logger;
+};