just some more thoughts

src2/CMakeLists.txt

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

src2/collection.h

@@ -30,30 +30,17 @@ private:
     std::map<std::string, std::filesystem::path> successSources;    //would be nice to have a bimap here
 };
 
-class Collection::UnknownSource : public std::exception {
+class Collection::UnknownSource : public std::runtime_error {
 public:
-    UnknownSource(const std::string& source);
+    explicit UnknownSource(const std::string& source);
-
-    const char* what() const noexcept( true ) override;
-private:
-    std::string source;
 };
 
-class Collection::DuplicateSource : public std::exception {
+class Collection::DuplicateSource : public std::runtime_error {
 public:
-    DuplicateSource(const std::string& source);
+    explicit DuplicateSource(const std::string& source);
-
-    const char* what() const noexcept( true ) override;
-private:
-    std::string source;
 };
 
-class Collection::DuplicatePath : public std::exception {
+class Collection::DuplicatePath : public std::runtime_error {
 public:
-    DuplicatePath(const std::string& source, const std::filesystem::path& path);
+    explicit DuplicatePath(const std::string& source, const std::filesystem::path& path);
-
-    const char* what() const noexcept( true ) override;
-private:
-    std::string source;
-    std::filesystem::path path;
 };

src2/component.cpp

@@ -0,0 +1,65 @@
+#include "component.h"
+
+#include <array>
+#include <string_view>
+
+constexpr std::array<std::string_view, Component::done + 1> stringStates {
+    "initial",
+    "reading",
+    "ready",
+    "building",
+    "done"
+};
+
+Component::Component(
+    const std::filesystem::path& path,
+    const std::shared_ptr<Collection>& collection,
+    const std::shared_ptr<TaskManager>& taskManager,
+    const std::shared_ptr<Logger>& logger
+):
+    Loggable(logger),
+    collection(collection),
+    taskManager(taskManager),
+    location(path)
+{}
+
+void Component::read() {
+    if (state != initial)
+        throw WrongState(state, "read");
+
+    try {
+        collection->addSource(location);
+    } catch (const Collection::DuplicateSource e) {
+        state = error;
+        throw e;
+    }
+    state = reading;
+    taskManager->queue(std::bind(&Component::performRead, this));
+}
+
+void Component::build(const std::filesystem::path& destination, const std::string& target) {
+    if (state != ready)
+        throw WrongState(state, "build");
+
+    state = building;
+    taskManager->queue(std::bind(&Component::performBuild, this, destination, target));
+}
+
+void Component::performRead() {
+}
+
+void Component::performBuild(std::filesystem::path destination, std::string target) {
+}
+
+Component::State Component::getState() const {
+    return state;
+}
+
+Component::Type Component::getType() const {
+    return type;
+}
+
+Component::WrongState::WrongState(State state, const std::string& action):
+    std::runtime_error("An attempt to perform action \"" + action
+                        + "\" on a wrong state \"" + stringStates[state].data() + '\"')
+{}

src2/component.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <string>
+#include <filesystem>
+#include <memory>
+#include <exception>
+#include <functional>
+
+#include "loggable.h"
+#include "loggger.h"
+#include "collection.h"
+#include "taskmanager.h"
+
+class Component : protected Loggable {
+public:
+    class WrongState;
+    enum State {
+        initial,
+        reading,
+        ready,
+        building,
+        error,
+        done
+    };
+
+    enum Type {
+        unknown,
+        file,
+        directory,
+        mason
+    };
+
+    Component(
+        const std::filesystem::path& path,
+        const std::shared_ptr<Collection>& collection,
+        const std::shared_ptr<TaskManager>& taskManager,
+        const std::shared_ptr<Logger>& logger
+    );
+
+    Type getType() const;
+    State getState() const;
+
+    void read();
+    void build(const std::filesystem::path& destination, const std::string& target);
+
+private:
+    void performRead();
+    void performBuild(std::filesystem::path destination, std::string target);
+
+private:
+    State state;
+    Type type;
+    std::shared_ptr<Collection> collection;
+    std::shared_ptr<TaskManager> taskManager;
+    std::filesystem::path location;
+};
+
+class Component::WrongState : public std::runtime_error {
+public:
+    explicit WrongState(State state, const std::string& action);
+};

src2/components/CMakeLists.txt

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

src2/components/component.cpp

@@ -1,23 +0,0 @@
-#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

@@ -1,53 +0,0 @@
-#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

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

src2/components/file.h

@@ -1,14 +0,0 @@
-#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/taskmanager.cpp

@@ -5,8 +5,8 @@ TaskManager::TaskManager() :
     stopping(false),
     maxThreads(std::thread::hardware_concurrency()),
     activeThreads(0),
-    queue(),
+    jobs(),
-    queueMutex(),
+    mutex(),
     loopConditional(),
     waitConditional(),
     threads()
@@ -18,8 +18,15 @@ TaskManager::~TaskManager() {
     stop();
 }
 
+void TaskManager::queue(const Job& job) {
+    std::unique_lock lock(mutex);
+    jobs.emplace(job);
+    lock.unlock();
+    loopConditional.notify_one();
+}
+
 void TaskManager::start() {
-    std::lock_guard lock(queueMutex);
+    std::lock_guard lock(mutex);
     if (running)
         return;
 
@@ -30,7 +37,7 @@ void TaskManager::start() {
 }
 
 void TaskManager::stop() {
-    std::unique_lock lock(queueMutex);
+    std::unique_lock lock(mutex);
     if (!running)
         return;
 
@@ -47,19 +54,19 @@ void TaskManager::stop() {
 void TaskManager::loop() {
     while (true) {
         Job job;
-        std::unique_lock lock(queueMutex);
+        std::unique_lock lock(mutex);
-        while (!stopping && queue.empty())
+        while (!stopping && jobs.empty())
             loopConditional.wait(lock);
 
         if (stopping)
             return;
 
         ++activeThreads;
-        job = queue.front();
+        job = jobs.front();
-        queue.pop();
+        jobs.pop();
         lock.unlock();
 
-        //do the job
+        job();
         lock.lock();
         --activeThreads;
         lock.unlock();
@@ -68,13 +75,13 @@ void TaskManager::loop() {
 
 }
 
-bool TaskManager::busy() {
+bool TaskManager::busy() const {
-    std::lock_guard lock(queueMutex);
+    std::lock_guard lock(mutex);
     return activeThreads == 0;
 }
 
-void TaskManager::wait() {
+void TaskManager::wait() const {
-    std::unique_lock lock(queueMutex);
+    std::unique_lock lock(mutex);
     while (activeThreads != 0)
         waitConditional.wait(lock);
 }

src2/taskmanager.h

@@ -6,17 +6,19 @@
 #include <thread>
 #include <mutex>
 #include <condition_variable>
+#include <functional>
 
 class TaskManager {
 public:
-    typedef std::string Job;
+    using Job = std::function<void ()>;
     TaskManager();
     ~TaskManager();
 
     void start();
     void stop();
-    void wait();
+    void wait() const;
-    bool busy();
+    void queue(const Job& job);
+    bool busy() const;
 
 private:
     void loop();
@@ -26,9 +28,9 @@ private:
     bool stopping;
     uint32_t maxThreads;
     uint32_t activeThreads;
-    std::queue<Job> queue;
+    std::queue<Job> jobs;
-    std::mutex queueMutex;
+    mutable std::mutex mutex;
-    std::condition_variable loopConditional;
+    mutable std::condition_variable loopConditional;
-    std::condition_variable waitConditional;
+    mutable std::condition_variable waitConditional;
     std::vector<std::thread> threads;
 };