wanda: restructure directory hierarchy

16 files changed, 1181 insertions, 0 deletions

diff --git a/include/wanda/command.hpp b/include/wanda/command.hpp
new file mode 100644
index 0000000..5ea1a08
--- /dev/null
+++ b/include/wanda/command.hpp
@@ -0,0 +1,46 @@
+#ifndef WANDA_COMMAND_HPP
+#define WANDA_COMMAND_HPP
+
+#include <wanda/message.hpp>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace wanda
+{
+  /**
+   * @brief An enum to describe different command IDs
+   */
+  enum struct command_id : char
+  {
+    change,  //< Change the wallpaper
+  };
+
+  /**
+   * @brief A simple type to represent commands transported through the control connection
+   */
+  struct command
+  {
+    command_id const id;
+    std::vector<std::string> const arguments;
+
+    /**
+     * @brief Convert the command to a message for transmission to a remote endpoint
+     */
+    std::optional<wanda::message> message() const;
+  };
+
+  /**
+   * @brief Extract a command from a message
+   */
+  std::optional<command> make_command(message message);
+
+  /**
+   * @brief A simple factory to create a "Change wallpaper" command
+   */
+  command make_change_command();
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/commander.hpp b/include/wanda/commander.hpp
new file mode 100644
index 0000000..1c76c6d
--- /dev/null
+++ b/include/wanda/commander.hpp
@@ -0,0 +1,66 @@
+#ifndef WANDA_COMMANDER_HPP
+#define WANDA_COMMANDER_HPP
+
+#include <wanda/command.hpp>
+#include <wanda/control_connection.hpp>
+#include <wanda/message.hpp>
+
+#include <asio.hpp>
+
+#include <filesystem>
+#include <memory>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace wanda
+{
+  /**
+   * @brief The remote control client
+   * 
+   */
+  struct commander : wanda::control_connection::listener
+  {
+    /**
+     * @brief The interface to be implemented by remote control listeners
+     */
+    struct listener
+    {
+      virtual void on_connected(commander & commander){};
+      virtual void on_response(commander & commander, std::string response){};
+      virtual void on_error(commander & commander, std::string error){};
+    };
+
+    /**
+     * @brief Construct a new commander
+     */
+    commander(asio::io_service & service, std::filesystem::path socket, listener & listener);
+
+    /**
+     * @brief Start communication with the remote daemon endpoint
+     */
+    void start();
+
+    /**
+     * @brief Stop communication with the remote daemon endpoint
+     */
+    void stop();
+
+    /**
+     * @brief Send a command to the remote daemon endpoint
+     */
+    void send(command command);
+
+    void on_error(control_connection::pointer connection, std::error_code error) override;
+    void on_received(control_connection::pointer connection, message message) override;
+
+  private:
+    asio::io_service & m_service;
+    wanda::control_connection::protocol::endpoint m_endpoint;
+    wanda::control_connection::protocol::socket m_socket;
+    wanda::control_connection::pointer m_connection;
+    listener & m_listener;
+  };
+
+}  // namespace wanda
+#endif
\ No newline at end of file
diff --git a/include/wanda/control_connection.hpp b/include/wanda/control_connection.hpp
new file mode 100644
index 0000000..b692d37
--- /dev/null
+++ b/include/wanda/control_connection.hpp
@@ -0,0 +1,114 @@
+#ifndef WANDA_CONTROL_CONNECTION_HPP
+#define WANDA_CONTROL_CONNECTION_HPP
+
+#include <wanda/keyed.hpp>
+#include <wanda/message.hpp>
+
+#include <asio.hpp>
+
+#include <istream>
+#include <memory>
+#include <ostream>
+#include <set>
+#include <string>
+#include <system_error>
+
+namespace wanda
+{
+  /**
+   * @brief A connection to a remote control endpoint
+   */
+  struct control_connection : keyed<control_connection>, std::enable_shared_from_this<control_connection>
+  {
+    using protocol = asio::local::stream_protocol;
+    using pointer = std::shared_ptr<control_connection>;
+
+    /**
+     * @brief The interface to be implemented by the control interface listener
+     */
+    struct listener
+    {
+      virtual void on_close(pointer connection) {}
+      virtual void on_received(pointer connection, message message) {}
+      virtual void on_error(pointer connection, std::error_code) {}
+    };
+
+    /**
+     * @brief A enum to describe different connection states
+     */
+    enum struct state : std::underlying_type_t<std::byte>
+    {
+      unknown,  //< Connection is in an unknown state
+      fresh,  //< Connection is freshly created but not established
+      established,  //< Connection has been established
+    };
+
+    /**
+     * @internal
+     * @brief Construct a new control connection object
+     * 
+     * @note This constructor is keyed on a private key type so it can only be constructed using the #wanda::make_connection factory
+     */
+    control_connection(key, protocol::socket socket);
+
+    /**
+     * @brief Add the given listener to this control connection's listener set
+     * 
+     * @returns <code>true</code> iff. the listener was not already in the listener set
+     */
+    bool add(listener * listener);
+
+    /**
+     * @brief Remove the given listener from this control connection's listener set
+     * 
+     * @return <code>true</code> iff. the listener was previously registered with this control connection
+     */
+    bool remove(listener * listener);
+
+    /**
+     * @brief Start I/O processing for this control connection
+     */
+    void start();
+
+    /**
+     * @brief Close this control connection
+     */
+    void close();
+
+    /**
+     * @brief Send the given message to the remote endpoint
+     */
+    void send(message message);
+
+    /**
+     * @brief Set the connection state to the provided state
+     */
+    void update(state state);
+
+    /**
+     * @brief Get the current connection state
+     */
+    state current_state() const;
+
+  private:
+    friend pointer make_control_connection(protocol::socket && socket);
+
+    void perform_read();
+
+    protocol::socket m_socket;
+    asio::streambuf m_in{};
+    asio::streambuf m_out{};
+    std::istream m_input{&m_in};
+    std::ostream m_output{&m_out};
+    std::set<listener *> m_listeners{};
+    state m_state{};
+  };
+
+  /**
+   * @brief Create a new control connection
+   */
+  control_connection::pointer make_control_connection(control_connection::protocol::socket && socket);
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/control_interface.hpp b/include/wanda/control_interface.hpp
new file mode 100644
index 0000000..73ef2cf
--- /dev/null
+++ b/include/wanda/control_interface.hpp
@@ -0,0 +1,96 @@
+/**
+ * @file   environment.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_CONTROL_INTERFACE_HPP
+#define WANDA_CONTROL_INTERFACE_HPP
+
+#include <wanda/command.hpp>
+#include <wanda/control_connection.hpp>
+#include <wanda/keyed.hpp>
+
+#include <asio.hpp>
+#include <spdlog/spdlog.h>
+
+#include <cstddef>
+#include <filesystem>
+#include <istream>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <type_traits>
+
+namespace wanda
+{
+  /**
+   * @brief An RAII type to delete a socket file upon destruction
+   */
+  struct socket_deleter
+  {
+    ~socket_deleter();
+
+    std::filesystem::path path;
+  };
+
+  /**
+   * @brief The daemon control interface
+   */
+  struct control_interface : control_connection::listener, keyed<control_interface>, std::enable_shared_from_this<control_interface>
+  {
+    using protocol = asio::local::stream_protocol;
+    using pointer = std::shared_ptr<control_interface>;
+
+    /**
+     * @brief The interface to be implemented by the control interface listener
+     */
+    struct listener
+    {
+      virtual void on_received(control_interface & interface, command command){};
+    };
+
+    /**
+     * @internal
+     * @brief Construct a new control interface object
+     * 
+     * @note This constructor is keyed on a private key type so it can only be constructed using the #wanda::make_interface factory
+     */
+    control_interface(key, asio::io_service & service, protocol::endpoint endpoint, listener & listener);
+
+    /**
+     * @brief Start handling of controller connections
+     */
+    std::error_code start();
+
+    /**
+     * @brief Stop the control interface
+     */
+    std::error_code shutdown();
+
+    void on_close(control_connection::pointer connection) override;
+    void on_received(control_connection::pointer connection, message message) override;
+
+  private:
+    void perform_accept();
+
+    friend pointer make_interface(asio::io_service & service, std::filesystem::path file, control_interface::listener & listener);
+
+    asio::io_service & m_service;
+    protocol::endpoint m_endpoint;
+    protocol::socket m_socket;
+    protocol::acceptor m_acceptor;
+    listener & m_listener;
+    socket_deleter m_deleter{m_endpoint.path()};
+    std::set<control_connection::pointer> m_connections;
+  };
+
+  /**
+   * @brief A factory to create new #control_interface instances
+   */
+  control_interface::pointer make_interface(asio::io_service & service, std::filesystem::path socket, control_interface::listener & listener);
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/deferred_failure.hpp b/include/wanda/deferred_failure.hpp
new file mode 100644
index 0000000..5db26f6
--- /dev/null
+++ b/include/wanda/deferred_failure.hpp
@@ -0,0 +1,21 @@
+/**
+ * @file   deferred_failure.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_DEFERRED_FAILURE_HPP
+#define WANDA_DEFERRED_FAILURE_HPP
+
+#include <type_traits>
+
+namespace
+{
+  /**
+   * @brief A helper type to defer static_assert failures
+   */
+  template<typename...>
+  using deferred_failure = std::false_type;
+}  // namespace
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/environment.hpp b/include/wanda/environment.hpp
new file mode 100644
index 0000000..5a702a8
--- /dev/null
+++ b/include/wanda/environment.hpp
@@ -0,0 +1,61 @@
+/**
+ * @file   environment.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_ENVIRONMENT_HPP
+#define WANDA_ENVIRONMENT_HPP
+
+#include <unistd.h>
+
+#include <map>
+#include <string>
+
+namespace wanda
+{
+  /**
+   * @brief A type to provide access to the runtime environment
+   */
+  struct environment
+  {
+    using map_type = std::map<std::string, std::string>;
+    using iterator = map_type::iterator;
+    using const_iterator = map_type::const_iterator;
+    using reference = map_type::reference;
+    using const_reference = map_type::const_reference;
+
+    /**
+     * @brief Construct a new environment from the given string array
+     */
+    explicit environment(char const * const * env = ::environ);
+
+    /**
+     * @brief Get the value of the given variable
+     * 
+     * @return A mutable reference to the value of the given environment variable
+     */
+    std::string & operator[](std::string const & variable);
+
+    /**
+     * @brief Get the value of the given variable
+     * 
+     * @return An immutable reference to the value of the given environment variable
+     */
+    std::string const & operator[](std::string const & variable) const;
+
+    iterator begin();
+    const_iterator begin() const;
+    const_iterator cbegin() const;
+
+    iterator end();
+    const_iterator end() const;
+    const_iterator cend() const;
+
+  private:
+    map_type m_cache{};
+  };
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/expected.hpp b/include/wanda/expected.hpp
new file mode 100644
index 0000000..fff0d81
--- /dev/null
+++ b/include/wanda/expected.hpp
@@ -0,0 +1,256 @@
+/**
+ * @file   expected.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_EXPECTED_HPP
+#define WANDA_EXPECTED_HPP
+
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+
+namespace wanda
+{
+  /**
+    * @brief A type to represent the error case of a computation based on #wanda::expected
+    */
+  template<typename ErrorType>
+  struct unexpected
+  {
+    static_assert(!std::is_same_v<ErrorType, void>, "ErrorType can not be 'void'!");
+    static_assert(!std::is_array_v<ErrorType>, "ErrorType can not be an array type!");
+
+    /**
+     * @brief Copy construct a new @p unexpected from another @p unexpected
+     */
+    constexpr unexpected(unexpected const &) = default;
+
+    /**
+     * @brief Move construct a new @p unexpected from another @p unexpected
+     */
+    constexpr unexpected(unexpected &&) = default;
+
+    /**
+     * @brief Construct a new @p unexpected by direct initializing the error object from @p args
+     */
+    template<typename... Args>
+    constexpr explicit unexpected(std::in_place_t, Args &&... args)
+        : m_error(std::forward<Args>(args)...)
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by direct initializing the error object from @p il and @p args
+     */
+    template<
+        typename U,
+        typename... Args,
+        std::enable_if_t<std::is_constructible_v<ErrorType, std::initializer_list<U>, Args...>> * = nullptr>
+    constexpr explicit unexpected(std::in_place_t, std::initializer_list<U> il, Args &&... args)
+        : m_error(il, std::forward<Args>(args)...)
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by direct initializing the error object from @p error
+     */
+    template<
+        typename Err = ErrorType,
+        std::enable_if_t<std::is_constructible_v<ErrorType, Err> &&
+                         !std::is_same_v<std::remove_cv_t<std::remove_reference_t<Err>>, std::in_place_t> &&
+                         !std::is_same_v<std::remove_cv_t<std::remove_reference_t<Err>>, unexpected>> * = nullptr>
+    constexpr explicit unexpected(Err && error)
+        : m_error(std::forward<Err>(error))
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by copying the value of another @p unexpected of different error type
+     */
+    template<
+        typename Err,
+        std::enable_if_t<!(
+            std::is_constructible_v<ErrorType, Err> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err>> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const> &&
+            !std::is_convertible_v<unexpected<Err> &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err>, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const, ErrorType>)> * = nullptr,
+        std::enable_if_t<!std::is_convertible_v<Err, ErrorType>> * = nullptr>
+    constexpr explicit unexpected(unexpected<Err> const & error)
+        : m_error(error.m_error)
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by copying the value of another @p unexpected of different error type
+     */
+    template<
+        typename Err,
+        std::enable_if_t<!(
+            std::is_constructible_v<ErrorType, Err> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err>> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const> &&
+            !std::is_convertible_v<unexpected<Err> &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err>, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const, ErrorType>)> * = nullptr,
+        std::enable_if_t<std::is_convertible_v<Err, ErrorType>> * = nullptr>
+    constexpr unexpected(unexpected<Err> const & error)
+        : m_error(error.m_error)
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by moving the value of another @p unexpected of different error type
+     */
+    template<
+        typename Err,
+        std::enable_if_t<!(
+            std::is_constructible_v<ErrorType, Err> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err>> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const> &&
+            !std::is_convertible_v<unexpected<Err> &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err>, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const, ErrorType>)> * = nullptr,
+        std::enable_if_t<!std::is_convertible_v<Err, ErrorType>> * = nullptr>
+    constexpr explicit unexpected(unexpected<Err> && error)
+        : m_error(std::move(error.m_error))
+    {
+    }
+
+    /**
+     * @brief Construct a new @p unexpected by moving the value of another @p unexpected of different error type
+     */
+    template<
+        typename Err,
+        std::enable_if_t<!(
+            std::is_constructible_v<ErrorType, Err> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err>> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const &> &&
+            !std::is_constructible_v<ErrorType, unexpected<Err> const> &&
+            !std::is_convertible_v<unexpected<Err> &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err>, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const &, ErrorType> &&
+            !std::is_convertible_v<unexpected<Err> const, ErrorType>)> * = nullptr,
+        std::enable_if_t<std::is_convertible_v<Err, ErrorType>> * = nullptr>
+    constexpr unexpected(unexpected<Err> && error)
+        : m_error(std::move(error.m_error))
+    {
+    }
+
+    /**
+     * @brief Get the error value contained in this @p unexpected instance
+     */
+    constexpr ErrorType const & value() const &
+    {
+      return m_error;
+    }
+
+    /**
+     * @brief Get the error value contained in this @p unexpected instance
+     */
+    constexpr ErrorType & value() &
+    {
+      return m_error;
+    }
+
+    /**
+     * @brief Get the error value contained in this @p unexpected instance
+     */
+    constexpr ErrorType && value() &&
+    {
+      return std::move(m_error);
+    }
+
+    /**
+     * @brief Get the error value contained in this @p unexpected instance
+     */
+    constexpr ErrorType const && value() const &&
+    {
+      return std::move(m_error);
+    }
+
+    /**
+     * @brief Swap the error value of this @p unexpected instance with the one of @p other
+     */
+    void swap(unexpected & other) noexcept(std::is_nothrow_swappable_v<ErrorType>)
+    {
+      using std::swap;
+      swap(m_error, other.m_error);
+    }
+
+    template<typename ErrorType1, typename ErrorType2>
+    friend constexpr bool operator==(unexpected<ErrorType1> const & lhs, unexpected<ErrorType2> const & rhs);
+
+    template<typename ErrorType1, typename ErrorType2>
+    friend constexpr bool operator!=(unexpected<ErrorType1> const & lhs, unexpected<ErrorType2> const & rhs);
+
+    template<
+        typename Err,
+        std::enable_if_t<std::is_swappable_v<Err>> *>
+    friend void swap(unexpected<Err> & lhs, unexpected<Err> & rhs);
+
+  private:
+    ErrorType m_error;
+  };
+
+  template<typename ErrorType>
+  unexpected(ErrorType)->unexpected<ErrorType>;
+
+  /**
+ * @brief Compare two @p unexpected instances for equality
+ */
+  template<typename ErrorType1, typename ErrorType2>
+  constexpr bool operator==(unexpected<ErrorType1> const & lhs, unexpected<ErrorType2> const & rhs)
+  {
+    return lhs.m_error == rhs.m_error;
+  }
+
+  /**
+ * @brief Compare two @p unexpected instances for inequality
+ */
+  template<typename ErrorType1, typename ErrorType2>
+  constexpr bool operator!=(unexpected<ErrorType1> const & lhs, unexpected<ErrorType2> const & rhs)
+  {
+    return lhs.m_error != rhs.m_error;
+  }
+
+  /**
+ * @brief Swap the error values of two @p unexpected instances
+ */
+  template<
+      typename Err,
+      std::enable_if_t<std::is_swappable_v<Err>> * = nullptr>
+  void swap(unexpected<Err> & lhs, unexpected<Err> & rhs)
+  {
+    lhs.swap(rhs);
+  }
+
+  /**
+ * @brief A tag type for @p unexpected
+ */
+  struct unexpect_t
+  {
+    explicit unexpect_t() = default;
+  };
+
+  /**
+ * @brief A tap for @p unexpected
+ */
+  inline constexpr unexpect_t unexpect{};
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/filesystem.hpp b/include/wanda/filesystem.hpp
new file mode 100644
index 0000000..1975bc5
--- /dev/null
+++ b/include/wanda/filesystem.hpp
@@ -0,0 +1,39 @@
+/**
+ * @file   filesystem.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_FILESYSTEM_HPP
+#define WANDA_FILESYSTEM_HPP
+
+#include <filesystem>
+#include <optional>
+#include <vector>
+
+namespace wanda
+{
+  /**
+   * @brief Covenience alias for path lists
+   */
+  using path_list = std::vector<std::filesystem::path>;
+
+  /**
+   * @brief The default scan filter, allowing only regular files to pass
+   */
+  constexpr inline auto default_filter = [](std::filesystem::path const & path) {
+    return is_regular_file(path);
+  };
+
+  /**
+   * @brief Scan the given folder for files
+   */
+  std::optional<path_list> scan(std::filesystem::path folder, bool(filter)(std::filesystem::path const &) = default_filter);
+
+  /**
+   * @brief Pick a random path from the given list
+   */
+  std::filesystem::path random_pick(path_list const & paths);
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/keyed.hpp b/include/wanda/keyed.hpp
new file mode 100644
index 0000000..58f17ad
--- /dev/null
+++ b/include/wanda/keyed.hpp
@@ -0,0 +1,28 @@
+/**
+ * @file   keyed.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_KEYED_HPP
+#define WANDA_KEYED_HPP
+
+namespace wanda
+{
+  /**
+   * @brief A tag type to prevent construction of a type without a factory
+   */
+  template<typename Derived>
+  struct keyed
+  {
+  protected:
+    struct key
+    {
+    };
+
+    explicit keyed(key) {}
+  };
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/logging.hpp b/include/wanda/logging.hpp
new file mode 100644
index 0000000..b3c1665
--- /dev/null
+++ b/include/wanda/logging.hpp
@@ -0,0 +1,35 @@
+/**
+ * @file   logging.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_LOGGING_HPP
+#define WANDA_LOGGING_HPP
+
+#include <spdlog/sinks/null_sink.h>
+#include <spdlog/spdlog.h>
+
+#include <memory>
+
+namespace wanda
+{
+  /**
+   * @brief A covenience alias to represent a handle for a logger
+   */
+  using logger_ptr = std::shared_ptr<spdlog::logger>;
+
+  /**
+   * @brief Initialize the shared logger
+   * 
+   * @note The logger will only ever be initialized once, even if this function is called multiple times
+   */
+  void initialize_logger(spdlog::sink_ptr sink = std::make_shared<spdlog::sinks::null_sink_st>());
+
+  /**
+   * @brief Get the shared logger
+   */
+  logger_ptr get_logger();
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/message.hpp b/include/wanda/message.hpp
new file mode 100644
index 0000000..866408f
--- /dev/null
+++ b/include/wanda/message.hpp
@@ -0,0 +1,83 @@
+/**
+ * @file   message.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_MESSAGE_HPP
+#define WANDA_MESSAGE_HPP
+
+#include <cstddef>
+#include <istream>
+#include <optional>
+#include <string>
+
+namespace wanda
+{
+  inline namespace v1
+  {
+    /**
+     * @brief The version argument for the hello message reflecting the current version
+     */
+    auto constexpr message_argument_hello = "1.0.0";
+  }  // namespace v1
+
+  /**
+   * @brief A tag to mark messages originating from the controller
+   */
+  auto constexpr message_source_controller = "C";
+
+  /**
+   * @brief A tag to mark messages originating from the daemon
+   */
+  auto constexpr message_source_daemon = "D";
+
+  /**
+   * @brief The command of the hello message
+   */
+  auto constexpr message_command_hello = "HELLO";
+
+  /**
+   * @brief A control protocol message, consisting of a @p source, @p command, and @p arguments
+   */
+  struct message
+  {
+    /**
+     * @brief Serialize this message into a string
+     */
+    explicit operator std::string() const;
+
+    /**
+     * @brief Get the size of the message as if it was serialized
+     */
+    std::size_t size() const;
+
+    /**
+     * @brief The source of the message
+     */
+    std::string source;
+
+    /**
+     * @brief The command of the message
+     */
+    std::string command;
+
+    /**
+     * @brief The arguments of the message command
+     */
+    std::optional<std::string> argument;
+  };
+
+  /**
+   * @brief Deserialize a message from the given stream
+   */
+  std::istream & operator>>(std::istream & in, message & message);
+
+  /**
+   * @brief Serialize a message to the given stream
+   */
+  std::ostream & operator<<(std::ostream & out, message const & message);
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/optional.hpp b/include/wanda/optional.hpp
new file mode 100644
index 0000000..da3774c
--- /dev/null
+++ b/include/wanda/optional.hpp
@@ -0,0 +1,65 @@
+/**
+ * @file   optional.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_OPTIONAL_HPP
+#define WANDA_OPTIONAL_HPP
+
+#include <optional>
+
+namespace wanda::std_ext
+{
+  /**
+   * @brief A type to represent a computation that could fail
+   */
+  struct failable
+  {
+    /**
+     * @brief A factory to create a successful computation
+     */
+    constexpr static auto success() { return failable{false}; }
+
+    /**
+     * @brief A factory to create a failed computation
+     */
+    constexpr static auto failure() { return failable{true}; }
+
+    /**
+     * @brief Execute the given handler if the computation failed
+     */
+    template<typename Handler>
+    constexpr void operator||(Handler handler) const
+    {
+      if (m_failed)
+      {
+        handler();
+      }
+    }
+
+  private:
+    constexpr explicit failable(bool failed)
+        : m_failed{failed} {};
+    bool const m_failed;
+  };
+
+  /**
+   * @brief Unwrap the given optional object, if present, and pass it to the handler
+   * 
+   * @return A successful computation iff. the object was present, a failed computation otherwise.
+   */
+  template<typename ObjectType, typename HandlerType>
+  auto with(std::optional<ObjectType> && object, HandlerType handler)
+  {
+    if (object)
+    {
+      handler(object.value());
+      return failable::success();
+    }
+    return failable::failure();
+  }
+
+}  // namespace wanda::std_ext
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/setting.hpp b/include/wanda/setting.hpp
new file mode 100644
index 0000000..98b5771
--- /dev/null
+++ b/include/wanda/setting.hpp
@@ -0,0 +1,160 @@
+/**
+ * @file    setting.hpp
+ * @author  Felix Morgner (felix.morgner@gmail.com)
+ * @since   1.0.0
+ */
+
+#ifndef WANDA_setting_HPP
+#define WANDA_setting_HPP
+
+#include <wanda/deferred_failure.hpp>
+#include <wanda/type_wrapper.hpp>
+
+#include <gio/gio.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <optional>
+#include <string>
+#include <variant>
+#include <vector>
+
+namespace wanda
+{
+  struct setting;
+
+  /**
+   * @brief A convenience type to represent setting keys
+   */
+  using key = type_wrapper<std::string, struct KeyTag>;
+
+  namespace literals
+  {
+    /**
+     * @brief UDL to create setting keys
+     */
+    key operator""_key(char const * str, std::size_t len);
+
+    /**
+     * @brief UDL to create setting schemas
+     */
+    std::optional<setting> operator""_setting(char const * str, std::size_t lent);
+  }  // namespace literals
+
+  /**
+   * @brief A simple wrapper for GSettings Schemas
+   */
+  struct setting
+  {
+    struct entry
+    {
+      using value_type = std::variant<std::monostate, bool, std::int32_t, std::int64_t, std::uint32_t, std::uint64_t, double, std::string, std::vector<std::string>>;
+
+      /**
+       * @brief Get the value of the settings entry
+       */
+      value_type operator*() const;
+
+      /**
+       * @brief Assign the given @p value to the settings entry
+       * 
+       * @returns @p true iff. the value could be successfully assigned
+       */
+      template<typename Type>
+      bool operator=(Type value)
+      {
+        struct setting_applier
+        {
+          setting_applier(GSettings * setting, gchar const * key, Type value) noexcept
+              : m_result{[&] {
+                if constexpr (std::is_same_v<Type, bool>)
+                {
+                  return g_settings_set_boolean(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, std::int32_t>)
+                {
+                  return g_settings_set_int(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, std::int64_t>)
+                {
+                  return g_settings_set_int64(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, std::uint32_t>)
+                {
+                  return g_settings_set_uint(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, std::uint64_t>)
+                {
+                  return g_settings_set_uint64(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, double>)
+                {
+                  return g_settings_set_double(setting, key, value);
+                }
+                else if constexpr (std::is_same_v<Type, std::string>)
+                {
+                  return g_settings_set_string(setting, key, value.c_str());
+                }
+                else if constexpr (std::is_same_v<Type, std::vector<std::string>>)
+                {
+                  auto temp = std::vector<gchar const *>{value.size() + 1};
+                  std::transform(value.begin(), value.end(), temp.begin(), [](auto const & str) { return str.c_str(); });
+                  return g_settings_set_strv(setting, key, temp.data());
+                }
+                else
+                {
+                  static_assert(deferred_failure<Type>{}, "Invalid argument type!");
+                }
+              }()}
+          {
+          }
+
+          ~setting_applier()
+          {
+            g_settings_sync();
+          }
+
+          operator bool() const
+          {
+            return m_result;
+          }
+
+        private:
+          gboolean const m_result;
+        };
+
+        return setting_applier{m_settings.get(), m_key.get().c_str(), value};
+      }
+
+    private:
+      entry(setting const & schema, key key);
+
+      std::unique_ptr<GSettings, decltype(&g_object_unref)> m_settings;
+
+      key m_key;
+
+      friend setting;
+    };
+
+    /**
+     * @brief Get the entry for the given key
+     * 
+     * @return An <code>std::optional</code> wrapping the entry associated with
+     * the given key, or an empty <code>std::optional</code> if the desired key
+     * does not exist in the setting's schema.
+     */
+    std::optional<entry> operator[](key key) const;
+
+  private:
+    explicit setting(GSettingsSchema * schema);
+
+    std::unique_ptr<GSettingsSchema, decltype(&g_settings_schema_unref)> m_schema;
+
+    friend std::optional<setting> literals::operator""_setting(char const *, std::size_t);
+  };
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/type_wrapper.hpp b/include/wanda/type_wrapper.hpp
new file mode 100644
index 0000000..12684cb
--- /dev/null
+++ b/include/wanda/type_wrapper.hpp
@@ -0,0 +1,47 @@
+/**
+ * @file   type_wrapper.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_TYPE_WRAPPER_HPP
+#define WANDA_TYPE_WRAPPER_HPP
+
+#include <utility>
+
+namespace wanda
+{
+  /**
+   * @brief A type to create a distinct type based on an existing type
+   * 
+   * @tparam InnerType The type to wrap
+   * @tparam TagType   A tag type to identify the distinct type
+   */
+  template<typename InnerType, typename TagType>
+  struct type_wrapper
+  {
+    /**
+     * @brief Construct a new type wrapper object
+     */
+    explicit type_wrapper(InnerType value)
+        : m_value{std::move(value)}
+    {
+    }
+
+    /**
+     * @brief Retrieve the wrapped value with its original type
+     */
+    constexpr explicit operator InnerType const &() const { return get(); }
+
+    /**
+     * @brief Retrieve the wrapped value with its original type
+     */
+    constexpr InnerType const & get() const { return m_value; }
+
+  private:
+    InnerType m_value;
+  };
+
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/wallpaper.hpp b/include/wanda/wallpaper.hpp
new file mode 100644
index 0000000..0cad473
--- /dev/null
+++ b/include/wanda/wallpaper.hpp
@@ -0,0 +1,24 @@
+/**
+ * @file   wallpaper.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_WALLPAPER_HPP
+#define WANDA_WALLPAPER_HPP
+
+#include <spdlog/sinks/null_sink.h>
+#include <spdlog/spdlog.h>
+
+#include <filesystem>
+#include <memory>
+
+namespace wanda
+{
+  /**
+   * @brief Set the wallpaper to the file specified by the given path
+   */
+  void set_wallpaper(std::filesystem::path wallpaper);
+}  // namespace wanda
+
+#endif
\ No newline at end of file
diff --git a/include/wanda/xdg.hpp b/include/wanda/xdg.hpp
new file mode 100644
index 0000000..bc138fa
--- /dev/null
+++ b/include/wanda/xdg.hpp
@@ -0,0 +1,40 @@
+/**
+ * @file   xdg.hpp
+ * @author Felix Morgner (felix.morgner@gmail.com)
+ * @since  1.0.0
+ */
+
+#ifndef WANDA_XDG_HPP
+#define WANDA_XDG_HPP
+
+#include <wanda/environment.hpp>
+
+#include <cstddef>
+#include <filesystem>
+#include <type_traits>
+
+namespace wanda
+{
+  /**
+   * @brief An @p enum to represet the standardized XDG directories
+   */
+  enum struct xdg_directory : std::underlying_type_t<std::byte>
+  {
+    data_home,
+    config_home,
+    cache_home,
+    runtime_dir,
+  };
+
+  /**
+   * @brief Get the name of the environment variable associated with the given XDG directory
+   */
+  std::string xdg_variable(xdg_directory directory);
+
+  /**
+   * @brief Get the path to the given @p directory given the provided @p environment
+   */
+  std::filesystem::path xdg_path_for(xdg_directory directory, environment const & environment);
+}  // namespace wanda
+
+#endif
\ No newline at end of file