Result

src/DBO/Result.h

 // Created by robin on 8/9/15.
 //
 
-#ifndef PDNS_SLAVE_RESULT_H
-#define PDNS_SLAVE_RESULT_H
+#ifndef RESULT_H
+#define RESULT_H
 
 # include <string>
 # include <vector>
+# include <iostream>
 
 template <class T> class Result
 {
 public:
-    Result();
-
-    Result(const T& data);
-
-    virtual ~Result();
-
-    Result<T>& ok(const T& data);
+    static const Result<T> ok(const T& data);
+    static const Result<T> strerror();
+    static const Result<T> error(const std::string& error);
+    template <class U> static const Result<T> error(const Result<U>& other);
 
     T& getData();
-
-    bool isSuccess() const;
-
-    Result<T>& addWarning(const std::string& warning);
-
-    const std::vector<std::string>& getWarnings() const;
-
-    Result<T>& error(const std::string& error);
-
+    const bool isSuccess() const;
     const std::string& getError() const;
 
     bool operator !() const;
-
     operator bool() const;
 
+    template<class U>
+    friend std::ostream& operator<<(std::ostream& os, const Result<U>& res);
+
     const Result<T>& print() const;
 
 private:
-    T _data;
+    Result();
 
-    std::vector<std::string> _warnings;
+    T _data;
 
     std::string _error;
+
+    bool _success;
 };
 
-typedef Result<bool> BResult;
+typedef Result<bool> ResultBool;
+
+typedef Result<int> ResultInt;
+
+typedef Result<long> ResultLong;
+
+typedef Result<float> ResultFloat;
+
+typedef Result<double> ResultDouble;
+
+typedef Result<char> ResultChar;
+
+typedef Result<std::string> ResultString;
 
 # include "DBO/Result.hxx"
 
-#endif //PDNS_SLAVE_RESULT_H
+#endif //RESULT_H

src/DBO/Result.hxx

 // Created by robin on 8/9/15.
 //
 
-#include <iostream>
 #include "Result.h"
+#include <errno.h>
+#include <string.h>
 
 template<class T>
 Result<T>::Result()
 }
 
 template<class T>
-Result<T>::Result(const T &data)
-        : _data(data)
+const Result<T> Result<T>::ok(const T& data)
 {
+    Result<T> r;
+    r._success = true;
+    r._data = data;
+    return r;
 }
 
 template<class T>
-Result<T>::~Result()
+const Result<T> Result<T>::strerror()
 {
+    Result<T> r;
+    r._success = false;
+    r._error = ::strerror(errno);
+    return r;
 }
 
 template<class T>
-Result<T> &Result<T>::ok(const T &data)
+const Result<T> Result<T>::error(const std::string& error)
 {
-    _data = data;
-    return *this;
+    Result<T> r;
+    r._success = false;
+    r._error = error;
+    return r;
 }
 
 template<class T>
-T &Result<T>::getData()
+template<class U>
+const Result<T> Result<T>::error(const Result<U>& other)
 {
-    return _data;
+    Result<T> r;
+    r._success = false;
+    r.error(other.getError());
+    return r;
 }
 
 template<class T>
-bool Result<T>::isSuccess() const
+T &Result<T>::getData()
 {
-    return _error.empty();
+    return _data;
 }
 
 template<class T>
-const std::vector<std::string>& Result<T>::getWarnings() const
+const bool Result<T>::isSuccess() const
 {
-    return _warnings;
-}
-
-template<class T>
-Result<T>& Result<T>::addWarning(const std::string &warning)
-{
-    _warnings.push_back(warning);
-    return *this;
+    return _success;
 }
 
 template<class T>
 }
 
 template<class T>
-Result<T> &Result<T>::error(const std::string &error)
+const std::string &Result<T>::getError() const
 {
-    _error = error;
-    return *this;
+    return _error;
 }
 
-template<class T>
-const std::string &Result<T>::getError() const
+template<class U>
+std::ostream& operator<<(std::ostream& os, const Result<U>& res)
 {
-    return _error;
+    if (res._success) {
+        os << "Success";// << res._data;
+    }
+    else {
+        os << "Error: " << (res._error.empty() ? "Unknown error" : res._error);
+    }
+    return os;
 }
 
 template<class T>
 const Result<T>& Result<T>::print() const
 {
-    for (auto warning : _warnings)
-        std::cerr << "WARNING: " << warning << std::endl;
-    if (!isSuccess())
-        std::cerr << "ERROR: " << _error << std::endl;
+    (_success ? std::cout : std::cerr) << *this << std::endl;
     return *this;
-}
+}