Replace Result.hpp with std::expected

src/DaggyCore/Core.cpp

@@ -311,8 +311,8 @@ try {
 
         auto provider = fabric->second->create(session_, {source_id, properties}, this);
         if (!provider) {
-            throw std::system_error(provider.error,
-                                    provider.message.toStdString());
+            throw std::system_error(provider.error().error,
+                                    provider.error().message.toStdString());
         }
 
         connect(*provider, &providers::IProvider::stateChanged, this, &Core::onDataProviderStateChanged);

src/DaggyCore/Result.hpp

@@ -22,71 +22,22 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 #pragma once
+#include <expected>
 #include <system_error>
 #include <utility>
-#include <optional>
 #include <QString>
 
 #include <DaggyCore/daggycore_export.h>
 #include "Errors.hpp"
 
 namespace daggy {
 
-template<typename Data>
-class Result
-{
-public:
-    Result() = delete;
-    Result(Data data)
-        : data_(std::move(data))
-        , error(errors::success)
-    {}
-
-    Result(std::error_code error,
-           QString message = QString())
-        : data_{}
-        , error(std::move(error))
-        , message(std::move(message))
-    {}
-
-    Result(const Result&) = delete;
-    Result(Result&&) = default;
-
-    operator bool() const
-    {
-        return !error;
-    }
-
-    Data&& operator*() {
-        return std::move(data_.operator*());
-    }
-
-    const Data& operator *() const {
-        return data_.operator*();
-    }
-
-    const Data* operator->() const {
-        return data_.operator->();
-    }
-
-    Data* operator->() {
-        return data_.operator->();
-    }
-
-    const Data* data() const {
-        return &data_.value();
-    }
-
-    Data* data() {
-        return &data_.value();
-    }
-
-    const std::error_code error;
-    const QString message;
-
-private:
-    std::optional<Data> data_;
+struct ResultError {
+    std::error_code error;
+    QString message;
 };
 
+template<typename Data>
+using Result = std::expected<Data, ResultError>;
 
 }

src/DaggyCore/Sources.cpp

@@ -57,28 +57,25 @@ daggy::Result<daggy::sources::Commands> getCommands(const QVariantMap& commands_
     const auto& keys = commands_map.keys();
     for (const QString& command_id : keys) {
         if (commands_map[command_id].metaType() != QMetaType(QMetaType::QVariantMap))
-            return
-            {
+            return std::unexpected(daggy::ResultError{
                 daggy::errors::make_error_code(DaggyErrorSourceConvertion),
                 QString("%1 command is not a map").arg(command_id)
-            };
+            });
         const QVariantMap& command_map = commands_map[command_id].toMap();
         static const auto& requeried_fields = required_commands_field.keys();
         for (const auto& field : requeried_fields) {
             if (!command_map.contains(field)) {
-                return
-                {
+                return std::unexpected(daggy::ResultError{
                     daggy::errors::make_error_code(DaggyErrorSourceConvertion),
                     QString("%1 command don't have required %2 field").arg(command_id, field)
-                };
+                });
             }
             if (command_map[field].metaType() != QMetaType(required_commands_field.value(field)))
             {
-                return
-                {
+                return std::unexpected(daggy::ResultError{
                     daggy::errors::make_error_code(DaggyErrorSourceConvertion),
                     QString("%1 command have incorrect type for %2 field").arg(command_id, field)
-                };
+                });
             }
         }
         daggy::sources::Command command{command_id,
@@ -90,7 +87,7 @@ daggy::Result<daggy::sources::Commands> getCommands(const QVariantMap& commands_
         }};
         commands[command.first] = command.second;
     }
-    return {std::move(commands)};
+    return commands;
 }
 }
 
@@ -244,7 +241,7 @@ struct convert<daggy::Sources>
 
             const auto& commands = getCommands(source_fields[g_commandsField].as<QVariantMap>());
             if (!commands) {
-                throw std::runtime_error(commands.error.message());
+                throw std::runtime_error(commands.error().message.toStdString());
                 return false;
             }
 
@@ -360,7 +357,7 @@ std::optional<daggy::Sources> daggy::sources::convertors::json(const QString& da
         if (!commands)
         {
             error = QString("%1 data source have incorrect commands. %2")
-                    .arg(source_id, std::move(commands.message));
+                    .arg(source_id, commands.error().message);
             return
             {};
         }

src/DaggyCore/providers/CLocalFabric.cpp

@@ -39,5 +39,5 @@ const QString& daggy::providers::CLocalFabric::type() const
 
 daggy::Result<daggy::providers::IProvider*> daggy::providers::CLocalFabric::createProvider(const QString& session, const Source& source, QObject* parent)
 {
-    return new CLocal(session, source.second.commands, parent);
+    return Result<daggy::providers::IProvider*>(new CLocal(session, source.second.commands, parent));
 }

src/DaggyCore/providers/CSsh2Fabric.cpp

@@ -57,10 +57,10 @@ daggy::Result<Ssh2Settings> convert(const QVariantMap& parameters)
 
     for (const auto& field : parameters_field) {
         if (parameters.contains(field.first) && parameters[field.first].metaType() != QMetaType(field.second))
-            return {
+            return std::unexpected(daggy::ResultError{
                 daggy::errors::make_error_code(DaggyErrorSourceConvertion),
                 QString("Parameters field '%1' has invalid type").arg(field.first)
-            };
+            });
     }
 
     if (parameters.contains(g_userField))
@@ -107,10 +107,7 @@ daggy::Result<daggy::providers::IProvider*> daggy::providers::CSsh2Fabric::creat
 {
     const auto parameters = convert(source.second.parameters);
     if (!parameters)
-        return
-        {
-            parameters.error, parameters.message
-        };
+        return std::unexpected(parameters.error());
 
     const auto& properties = source.second;
 
@@ -120,9 +117,9 @@ daggy::Result<daggy::providers::IProvider*> daggy::providers::CSsh2Fabric::creat
     else
         host = QHostAddress(properties.host);
 
-    return new CSsh2(session,
+    return Result<daggy::providers::IProvider*>(new CSsh2(session,
                      std::move(host),
                      std::move(*parameters),
                      properties.commands,
-                     parent);
+                     parent));
 }

src/DaggyCore/providers/CSshFabric.cpp

@@ -29,10 +29,10 @@ daggy::Result<daggy::providers::CSsh::Settings> convert(const QVariantMap& param
 
     for (const auto& field : parameters_field) {
         if (parameters.contains(field.first) && parameters[field.first].metaType() != QMetaType(field.second))
-            return {
+            return std::unexpected(daggy::ResultError{
                 daggy::errors::make_error_code(DaggyErrorSourceConvertion),
                 QString("Parameters field '%1' has invalid type").arg(field.first)
-            };
+            });
     }
 
     if (parameters.contains(g_configField))
@@ -68,22 +68,19 @@ daggy::Result<IProvider*> CSshFabric::createProvider(const QString& session, con
 {
     auto parameters = convert(source.second.parameters);
     if (!parameters) {
-        return
-            {
-                parameters.error, parameters.message
-            };
+        return std::unexpected(parameters.error());
     }
 
     const auto& properties = source.second;
     QString host = properties.host;
     if (host.isEmpty())
         host = source.first;
 
-    return new CSsh(session,
+    return Result<IProvider*>(new CSsh(session,
                     host,
                     std::move(*parameters),
                     properties.commands,
-                    parent);
+                    parent));
 }
 }
 }

src/DaggyCore/providers/IFabric.cpp

@@ -41,11 +41,10 @@ daggy::Result<daggy::providers::IProvider*> daggy::providers::IFabric::create(co
 {
     const auto& properties = source.second;
     if (properties.type != type()) {
-        return
-        {
+        return std::unexpected(daggy::ResultError{
             errors::make_error_code(DaggyErrorSourceIncorrectProviderType),
             QString("Source %1 has incorrect provider type %2 - type %3 is required").arg(source.first, properties.type, type())
-        };
+        });
     }
     return createProvider(session, source, parent);
 }