From 652c5eb52338111b89de5842ec2c63c4f693debc Mon Sep 17 00:00:00 2001
From: Claudius Holeksa <mail@keldu.de>
Date: Tue, 2 May 2023 17:54:06 +0200
Subject: c++: renamed to snake_case and changed to new errors in io-tls

---
 forstio/async/async.cpp    |  2 +-
 forstio/async/async.h      | 24 ++++++++--------
 forstio/async/async.tmpl.h | 28 +++++++++----------
 forstio/core/error.h       | 22 ++++++++++++++-
 forstio/io-tls/tls.cpp     | 70 ++++++++++++++++++++++++----------------------
 forstio/io-tls/tls.h       | 44 ++++++++++++++---------------
 forstio/io/io.h            |  9 ++++++
 forstio/io/io_helpers.cpp  | 12 ++++----
 8 files changed, 120 insertions(+), 91 deletions(-)

diff --git a/forstio/async/async.cpp b/forstio/async/async.cpp
index ca85b30..c53ffa6 100644
--- a/forstio/async/async.cpp
+++ b/forstio/async/async.cpp
@@ -29,7 +29,7 @@ conveyor_node_with_child_mixin::conveyor_node_with_child_mixin(
 error_or<own<conveyor_node>>
 conveyor_node_with_child_mixin::swap_child(own<conveyor_node> &&swapee) {
 	SAW_ASSERT(child) {
-		return critical_error("Child should exist if this function is called");
+		return make_error<err::invalid_state>("Child should exist if this function is called");
 	}
 	own<conveyor_node> old_child = std::move(child);
 
diff --git a/forstio/async/async.h b/forstio/async/async.h
index 82eb2c1..4cfed60 100644
--- a/forstio/async/async.h
+++ b/forstio/async/async.h
@@ -63,7 +63,7 @@ public:
 	error_or<own<conveyor_node>>
 	swap_child_of_parent(own<conveyor_node> &&swapee) {
 		SAW_ASSERT(parent) {
-			return critical_error(
+			return make_error<err::invalid_state>(
 				"Can't swap child, because parent doesn't exist");
 		}
 
@@ -737,21 +737,21 @@ public:
 				try {
 
 					eov = fix_void_caller<T, DepT>::apply(
-						func_, std::move(dep_eov.value()));
+						func_, std::move(dep_eov.get_value()));
 				} catch (const std::bad_alloc &) {
-					eov = critical_error("Out of memory");
+					eov = make_error<err::out_of_memory>("Out of memory");
 				} catch (const std::exception &) {
-					eov = critical_error(
+					eov = make_error<err::invalid_state>(
 						"Exception in chain occured. Return ErrorOr<T> if you "
 						"want to handle errors which are recoverable");
 				}
 			} else if (dep_eov.is_error()) {
-				eov = error_func_(std::move(dep_eov.error()));
+				eov = error_func_(std::move(dep_eov.get_error()));
 			} else {
-				eov = critical_error("No value set in dependency");
+				eov = make_error<err::invalid_state>("No value set in dependency");
 			}
 		} else {
-			eov = critical_error("Conveyor doesn't have child");
+			eov = make_error<err::invalid_state>("Conveyor doesn't have child");
 		}
 	}
 };
@@ -790,7 +790,7 @@ public:
 	// ConveyorNode
 	void get_result(error_or_value &err_or_val) noexcept override {
 		err_or_val.as<void_t>() =
-			critical_error("In a sink node no result can be returned");
+			make_error<err::invalid_state>("In a sink node no result can be returned");
 	}
 
 	error_or<own<conveyor_node>>
@@ -804,13 +804,13 @@ public:
 			error_or<void> dep_eov;
 			child_mixin_.child->get_result(dep_eov);
 			if (dep_eov.is_error()) {
-				if (dep_eov.error().is_critical()) {
+				if (dep_eov.get_error().is_critical()) {
 					if (!is_armed()) {
 						arm_last();
 					}
 				}
 				if (conveyor_sink_) {
-					conveyor_sink_->fail(std::move(dep_eov.error()));
+					conveyor_sink_->fail(std::move(dep_eov.get_error()));
 				}
 			}
 		}
@@ -840,7 +840,7 @@ public:
 	error_or<own<conveyor_node>>
 	swap_child(own<conveyor_node> &&swapee) noexcept override {
 		(void)swapee;
-		return recoverable_error("Node doesn't support swapping");
+		return make_error<err::not_supported>("Node doesn't support swapping");
 	}
 
 	conveyor_storage *next_storage() noexcept override {
@@ -869,7 +869,7 @@ public:
 	void get_result(error_or_value &err_or_val) noexcept override {
 		if (retrieved_ > 0) {
 			err_or_val.as<fix_void<T>>() =
-				make_error("Already taken value", error::code::Exhausted);
+				make_error<err::buffer_exhausted>("Already taken value");
 		} else {
 			err_or_val.as<fix_void<T>>() = std::move(value_);
 		}
diff --git a/forstio/async/async.tmpl.h b/forstio/async/async.tmpl.h
index 77a24da..d081fa9 100644
--- a/forstio/async/async.tmpl.h
+++ b/forstio/async/async.tmpl.h
@@ -151,7 +151,7 @@ own<conveyor_node> conveyor<T>::from_conveyor(conveyor<T> conveyor) {
 template <typename T> error_or<fix_void<T>> conveyor<T>::take() {
 	SAW_ASSERT(node_) {
 		return error_or<fix_void<T>>{
-			critical_error("conveyor in invalid state")};
+			make_error<err::invalid_state>("conveyor in invalid state")};
 	}
 	conveyor_storage *storage = node_->next_storage();
 	if (storage) {
@@ -161,11 +161,11 @@ template <typename T> error_or<fix_void<T>> conveyor<T>::take() {
 			return result;
 		} else {
 			return error_or<fix_void<T>>{
-				recoverable_error("conveyor buffer has no elements")};
+				make_error<err::buffer_exhausted>("conveyor buffer has no elements")};
 		}
 	} else {
 		return error_or<fix_void<T>>{
-			critical_error("conveyor node has no child storage")};
+			make_error<err::invalid_state>("conveyor node has no child storage")};
 	}
 }
 
@@ -187,7 +187,7 @@ template <typename T> void queue_buffer_conveyor_node<T>::fire() {
 	if (child_mixin_.child) {
 		if (!storage_.empty()) {
 			if (storage_.front().is_error()) {
-				if (storage_.front().error().is_critical()) {
+				if (storage_.front().get_error().is_critical()) {
 					child_mixin_.child = nullptr;
 				}
 			}
@@ -237,7 +237,7 @@ template <typename T> void queue_buffer_conveyor_node<T>::child_has_fired() {
 		child_mixin_.child->get_result(eov);
 
 		if (eov.is_error()) {
-			if (eov.error().is_critical()) {
+			if (eov.get_error().is_critical()) {
 			}
 		}
 
@@ -327,7 +327,7 @@ template <typename T>
 error_or<own<conveyor_node>>
 merge_conveyor_node<T>::swap_child(own<conveyor_node> &&swapee_) noexcept {
 	(void)swapee_;
-	return critical_error(
+	return make_error<err::invalid_state>(
 		"merge_conveyor_node<T>::appendage should block calls to this class");
 }
 
@@ -359,7 +359,7 @@ void merge_conveyor_node<T>::get_result(error_or_value &eov) noexcept {
 		}
 	}
 
-	err_or_val = critical_error("No value in Merge appendages");
+	err_or_val = make_error<err::invalid_state>("No value in Merge appendages");
 }
 
 template <typename T> void merge_conveyor_node<T>::fire() {
@@ -414,7 +414,7 @@ merge_conveyor_node<T>::appendage::swap_child(own<conveyor_node> &&swapee_) {
 	child = std::move(swapee_);
 
 	// This case should never happen
-	SAW_ASSERT(old_child) { return critical_error("No child exists"); }
+	SAW_ASSERT(old_child) { return make_error<err::invalid_state>("No child exists"); }
 
 	return old_child;
 }
@@ -425,7 +425,7 @@ void merge_conveyor_node<T>::appendage::get_result(error_or_value &eov) {
 
 	SAW_ASSERT(queued() > 0) {
 		err_or_val =
-			critical_error("No element queued in Merge appendage Node");
+			make_error<err::invalid_state>("No element queued in Merge appendage Node");
 		return;
 	}
 
@@ -461,7 +461,7 @@ void merge_conveyor_node<T>::appendage::get_appendage_result(
 
 	SAW_ASSERT(queued() > 0) {
 		err_or_val =
-			critical_error("No element queued in Merge appendage Node");
+			make_error<err::invalid_state>("No element queued in Merge appendage Node");
 		return;
 	}
 
@@ -573,7 +573,7 @@ template <typename T> size_t adapt_conveyor_feeder<T>::space() const {
 
 template <typename T>
 error adapt_conveyor_feeder<T>::swap(conveyor<T> &&conv) noexcept {
-	SAW_ASSERT(feedee_) { return critical_error("No feedee connected"); }
+	SAW_ASSERT(feedee_) { return make_error<err::invalid_state>("No feedee connected"); }
 
 	auto node = conveyor<T>::from_conveyor(std::move(conv));
 
@@ -602,7 +602,7 @@ adapt_conveyor_node<T>::swap_child(own<conveyor_node> &&swapee) noexcept {
 		return myself_err;
 	}
 
-	auto &myself = myself_err.value();
+	auto &myself = myself_err.get_value();
 
 	assert(myself.get() == this);
 
@@ -649,7 +649,7 @@ void adapt_conveyor_node<T>::get_result(error_or_value &err_or_val) {
 		err_or_val.as<T>() = std::move(storage_.front());
 		storage_.pop();
 	} else {
-		err_or_val.as<T>() = critical_error(
+		err_or_val.as<T>() = make_error<err::invalid_state>(
 			"Signal for retrieval of storage sent even though no "
 			"data is present");
 	}
@@ -754,7 +754,7 @@ void one_time_conveyor_node<T>::get_result(error_or_value &err_or_val) {
 		err_or_val.as<T>() = std::move(storage_.value());
 		storage_ = std::nullopt;
 	} else {
-		err_or_val.as<T>() = critical_error(
+		err_or_val.as<T>() = make_error<err::invalid_state>(
 			"Signal for retrieval of storage sent even though no "
 			"data is present");
 	}
diff --git a/forstio/core/error.h b/forstio/core/error.h
index 304b375..9708a07 100644
--- a/forstio/core/error.h
+++ b/forstio/core/error.h
@@ -115,6 +115,16 @@ struct no_error {
 	static constexpr bool is_critical = false;
 };
 
+struct recoverable {
+	static constexpr std::string_view description = "No error has occured";
+	static constexpr bool is_critical = false;
+};
+
+struct critical {
+	static constexpr std::string_view description = "No error has occured";
+	static constexpr bool is_critical = true;
+};
+
 struct buffer_exhausted {
 	static constexpr std::string_view description = "Buffer is too small";
 	static constexpr bool is_critical = false;
@@ -129,6 +139,16 @@ struct out_of_memory {
 	static constexpr std::string_view description = "Out of memory";
 	static constexpr bool is_critical = true;
 };
+
+struct invalid_state {
+	static constexpr std::string_view description = "Invalid state";
+	static constexpr bool is_critical = true;
+};
+
+struct not_supported {
+	static constexpr std::string_view description = "Not supported";
+	static constexpr bool is_critical = false;
+};
 }
 
 /**
@@ -163,7 +183,7 @@ private:
 				  "Don't use internal private types");
 
 public:
-	error_or() = default;
+	error_or():value_or_error_{fix_void<T>{}}{}
 	error_or(const fix_void<T> &value) : value_or_error_{value} {}
 
 	error_or(fix_void<T> &&value) : value_or_error_{std::move(value)} {}
diff --git a/forstio/io-tls/tls.cpp b/forstio/io-tls/tls.cpp
index c1497bc..9fa143c 100644
--- a/forstio/io-tls/tls.cpp
+++ b/forstio/io-tls/tls.cpp
@@ -11,18 +11,18 @@
 
 namespace saw {
 
-class Tls::Impl {
+class tls::impl {
 public:
 	gnutls_certificate_credentials_t xcred;
 
 public:
-	Impl() {
+	impl() {
 		gnutls_global_init();
 		gnutls_certificate_allocate_credentials(&xcred);
 		gnutls_certificate_set_x509_system_trust(xcred);
 	}
 
-	~Impl() {
+	~impl() {
 		gnutls_certificate_free_credentials(xcred);
 		gnutls_global_deinit();
 	}
@@ -32,32 +32,34 @@ static ssize_t forst_tls_push_func(gnutls_transport_ptr_t p, const void *data,
 						 size_t size);
 static ssize_t forst_tls_pull_func(gnutls_transport_ptr_t p, void *data, size_t size);
 
-Tls::Tls() : impl{heap<Tls::Impl>()} {}
+tls::tls() : impl_{heap<tls::impl>()} {}
 
-Tls::~Tls() {}
+tls::~tls() {}
 
-Tls::Impl &Tls::getImpl() { return *impl; }
+tls::impl &tls::get_impl() { return *impl_; }
 
-class TlsIoStream final : public io_stream {
+class tls_io_stream final : public io_stream {
 private:
 	own<io_stream> internal;
 	gnutls_session_t session_handle;
 
 public:
-	TlsIoStream(own<io_stream> internal_) : internal{std::move(internal_)} {}
+	tls_io_stream(own<io_stream> internal_) : internal{std::move(internal_)} {}
 
-	~TlsIoStream() { gnutls_bye(session_handle, GNUTLS_SHUT_RDWR); }
+	~tls_io_stream() { gnutls_bye(session_handle, GNUTLS_SHUT_RDWR); }
 
 	error_or<size_t> read(void *buffer, size_t length) override {
 		ssize_t size = gnutls_record_recv(session_handle, buffer, length);
 		if (size < 0) {
 			if(gnutls_error_is_fatal(size) == 0){
-				return recoverable_error([size](){return std::string{"Read recoverable Error "}+std::string{gnutls_strerror(size)};}, "Error read r");
+				return make_error<err::recoverable>("Recoverable error on read in gnutls. TODO better error msg handling");
+				// Leaving proper message handling done in previous error framework
+				//return recoverable_error([size](){return std::string{"Read recoverable Error "}+std::string{gnutls_strerror(size)};}, "Error read r");
 			}else{
-				return critical_error([size](){return std::string{"Read critical Error "}+std::string{gnutls_strerror(size)};}, "Error read c");
+				return make_error<err::critical>("Fatal error on read in gnutls. TODO better error msg handling");
 			}
 		}else if(size == 0){
-			return critical_error("Disconnected");
+			return make_error<err::disconnected>();
 		}
 
 		return static_cast<size_t>(length);
@@ -73,9 +75,9 @@ public:
 		ssize_t size = gnutls_record_send(session_handle, buffer, length);
 		if(size < 0){
 			if(gnutls_error_is_fatal(size) == 0){
-				return recoverable_error([size](){return std::string{"Write recoverable Error "}+std::string{gnutls_strerror(size)} + " " + std::to_string(size);}, "Error write r");
+				return make_error<err::recoverable>("Recoverable error on write in gnutls. TODO better error msg handling");
 			}else{
-				return critical_error([size](){return std::string{"Write critical Error "}+std::string{gnutls_strerror(size)} + " " + std::to_string(size);}, "Error write c");
+				return make_error<err::critical>("Fatal error on write in gnutls. TODO better error msg handling");
 			}
 		}
 
@@ -87,15 +89,15 @@ public:
 	gnutls_session_t &session() { return session_handle; }
 };
 
-TlsServer::TlsServer(own<server> srv) : internal{std::move(srv)} {}
+tls_server::tls_server(own<server> srv) : internal{std::move(srv)} {}
 
-conveyor<own<io_stream>> TlsServer::accept() {
+conveyor<own<io_stream>> tls_server::accept() {
 	SAW_ASSERT(internal) { return conveyor<own<io_stream>>{fix_void<own<io_stream>>{nullptr}}; }
 	return internal->accept().then([](own<io_stream> stream) -> own<io_stream> {
 		/// @todo handshake
 
 
-		return heap<TlsIoStream>(std::move(stream));
+		return heap<tls_io_stream>(std::move(stream));
 	});
 }
 
@@ -103,16 +105,16 @@ namespace {
 /*
 * Small helper for setting up the nonblocking connection handshake
 */
-struct TlsClientStreamHelper {
+struct tls_client_stream_helper {
 public:
 	own<conveyor_feeder<own<io_stream>>> feeder;
 	conveyor_sink connection_sink;
 	conveyor_sink stream_reader;
 	conveyor_sink stream_writer;
 
-	own<TlsIoStream> stream = nullptr;
+	own<tls_io_stream> stream = nullptr;
 public:
-	TlsClientStreamHelper(own<conveyor_feeder<own<io_stream>>> f):
+	tls_client_stream_helper(own<conveyor_feeder<own<io_stream>>> f):
 		feeder{std::move(f)}
 	{}
 
@@ -145,7 +147,7 @@ public:
 			} while ( (ret == GNUTLS_E_AGAIN || ret == GNUTLS_E_INTERRUPTED) && gnutls_error_is_fatal(ret) == 0);
 
 			if(gnutls_error_is_fatal(ret)){
-				feeder->fail(critical_error("Couldn't create Tls connection"));
+				feeder->fail(make_error<err::critical>("Couldn't create Tls connection"));
 				stream = nullptr;
 			}else if(ret == GNUTLS_E_SUCCESS){
 				feeder->feed(std::move(stream));
@@ -155,21 +157,21 @@ public:
 };
 }
 
-own<server> TlsNetwork::listen(network_address& address) {
-	return heap<TlsServer>(internal.listen(address));
+own<server> tls_network::listen(network_address& address) {
+	return heap<tls_server>(internal.listen(address));
 }
 
-conveyor<own<io_stream>> TlsNetwork::connect(network_address& address) {
+conveyor<own<io_stream>> tls_network::connect(network_address& address) {
 	// Helper setups
 	auto caf = new_conveyor_and_feeder<own<io_stream>>();
-	own<TlsClientStreamHelper> helper = heap<TlsClientStreamHelper>(std::move(caf.feeder));
-	TlsClientStreamHelper* hlp_ptr = helper.get();
+	own<tls_client_stream_helper> helper = heap<tls_client_stream_helper>(std::move(caf.feeder));
+	tls_client_stream_helper* hlp_ptr = helper.get();
 	
 	// Conveyor entangled structure
 	auto prim_conv = internal.connect(address).then([this, hlp_ptr, addr = address.address()](
 										own<io_stream> stream) -> error_or<void> {
 		io_stream* inner_stream = stream.get();
-		auto tls_stream = heap<TlsIoStream>(std::move(stream));
+		auto tls_stream = heap<tls_io_stream>(std::move(stream));
 
 		auto &session = tls_stream->session();
 
@@ -180,7 +182,7 @@ conveyor<own<io_stream>> TlsNetwork::connect(network_address& address) {
 
 		gnutls_set_default_priority(session);
 		gnutls_credentials_set(session, GNUTLS_CRD_CERTIFICATE,
-							   tls.getImpl().xcred);
+							   tls_.get_impl().xcred);
 		gnutls_session_set_verify_cert(session, addr.c_str(), 0);
 
 		gnutls_transport_set_ptr(session, reinterpret_cast<gnutls_transport_ptr_t>(inner_stream));
@@ -201,7 +203,7 @@ conveyor<own<io_stream>> TlsNetwork::connect(network_address& address) {
 	return caf.conveyor.attach(std::move(helper));
 }
 
-own<datagram> TlsNetwork::datagram(network_address& address){
+own<datagram> tls_network::datagram(network_address& address){
 	///@unimplemented
 	return nullptr;
 }
@@ -218,7 +220,7 @@ static ssize_t forst_tls_push_func(gnutls_transport_ptr_t p, const void *data,
 		return -1;
 	}
 
-	return static_cast<ssize_t>(length.value());
+	return static_cast<ssize_t>(length.get_value());
 }
 
 static ssize_t forst_tls_pull_func(gnutls_transport_ptr_t p, void *data, size_t size) {
@@ -232,19 +234,19 @@ static ssize_t forst_tls_pull_func(gnutls_transport_ptr_t p, void *data, size_t
 		return -1;
 	}
 
-	return static_cast<ssize_t>(length.value());
+	return static_cast<ssize_t>(length.get_value());
 }
 
-TlsNetwork::TlsNetwork(Tls& tls_, network &network) : tls{tls_},internal{network} {}
+tls_network::tls_network(tls& tls_, network &network) : tls_{tls_},internal{network} {}
 
-conveyor<own<network_address>> TlsNetwork::resolve_address(const std::string &addr,
+conveyor<own<network_address>> tls_network::resolve_address(const std::string &addr,
 													   uint16_t port) {
 	/// @todo tls server name needed. Check validity. Won't matter later on, because gnutls should fail anyway. But
 	/// it's better to find the error source sooner rather than later
 	return internal.resolve_address(addr, port);
 }
 
-std::optional<own<TlsNetwork>> setupTlsNetwork(network &network) {
+std::optional<own<tls_network>> setup_tls_network(network &network) {
 	return std::nullopt;
 }
 } // namespace saw
diff --git a/forstio/io-tls/tls.h b/forstio/io-tls/tls.h
index 8a31c1d..74b39ff 100644
--- a/forstio/io-tls/tls.h
+++ b/forstio/io-tls/tls.h
@@ -7,24 +7,24 @@
 #include <variant>
 
 namespace saw {
-class Tls;
+class tls;
 
-class TlsServer final : public server {
+class tls_server final : public server {
 private:
 	own<server> internal;
 
 public:
-	TlsServer(own<server> srv);
+	tls_server(own<server> srv);
 
 	conveyor<own<io_stream>> accept() override;
 };
 
-class TlsNetwork final : public network {
+class tls_network final : public network {
 private:
-	Tls& tls;
+	tls& tls_;
 	network &internal;
 public:
-	TlsNetwork(Tls& tls_, network &network_);
+	tls_network(tls& tls_, network &network_);
 
 	conveyor<own<network_address>> resolve_address(const std::string &addr, uint16_t port = 0) override;
 	
@@ -36,35 +36,33 @@ public:
 };
 
 /**
-* Tls context class.
+* tls context class.
 * Provides tls network class which ensures the usage of tls encrypted connections
 */
-class Tls {
+class tls {
 private:
-	class Impl;
-	own<Impl> impl;
+	class impl;
+	own<impl> impl_;
 public:
-	Tls();
-	~Tls();
+	tls();
+	~tls();
 
-	struct Version {
-		struct Tls_1_0{};
-		struct Tls_1_1{};
-		struct Tls_1_2{};
+	struct version {
+		struct tls_1_0{};
+		struct tls_1_1{};
+		struct tls_1_2{};
 	};
 
-	struct Options {
+	struct options {
 	public:
-		Version version;
+		version version;
 	};
 
-	network& tlsNetwork();
-
-	Impl &getImpl();
+	impl &get_impl();
 private:
-	Options options;
+	options options_;
 };
 
-std::optional<own<TlsNetwork>> setupTlsNetwork(network &network);
+std::optional<own<tls_network>> setup_tls_network(network &network);
 
 } // namespace saw
diff --git a/forstio/io/io.h b/forstio/io/io.h
index 4a87da5..bcc59fd 100644
--- a/forstio/io/io.h
+++ b/forstio/io/io.h
@@ -8,6 +8,15 @@
 #include <variant>
 
 namespace saw {
+/**
+ * Set of error common in io
+ */
+namespace err {
+struct disconnected {
+	static constexpr std::string_view description = "Disconnected";
+	static constexpr bool is_critical = true;
+};
+}
 /*
  * Input stream
  */
diff --git a/forstio/io/io_helpers.cpp b/forstio/io/io_helpers.cpp
index 47c5017..c2cf2be 100644
--- a/forstio/io/io_helpers.cpp
+++ b/forstio/io/io_helpers.cpp
@@ -11,7 +11,7 @@ void read_task_and_step_helper::read_step(input_stream &reader) {
 
 		error_or<size_t> n_err = reader.read(task.buffer, task.max_length);
 		if (n_err.is_error()) {
-			const error &error = n_err.error();
+			const error &error = n_err.get_error();
 			if (error.is_critical()) {
 				if (read_done) {
 					read_done->fail(error.copy_error());
@@ -21,7 +21,7 @@ void read_task_and_step_helper::read_step(input_stream &reader) {
 
 			break;
 		} else if (n_err.is_value()) {
-			size_t n = n_err.value();
+			size_t n = n_err.get_value();
 			if (static_cast<size_t>(n) >= task.min_length &&
 				static_cast<size_t>(n) <= task.max_length) {
 				if (read_done) {
@@ -37,7 +37,7 @@ void read_task_and_step_helper::read_step(input_stream &reader) {
 
 		} else {
 			if (read_done) {
-				read_done->fail(critical_error("Read failed"));
+				read_done->fail(make_error<err::invalid_state>("Read failed"));
 			}
 			read_task = std::nullopt;
 		}
@@ -52,7 +52,7 @@ void write_task_and_step_helper::write_step(output_stream &writer) {
 
 		if (n_err.is_value()) {
 
-			size_t n = n_err.value();
+			size_t n = n_err.get_value();
 			assert(n <= task.length);
 			if (n == task.length) {
 				if (write_done) {
@@ -65,7 +65,7 @@ void write_task_and_step_helper::write_step(output_stream &writer) {
 				task.already_written += n;
 			}
 		} else if (n_err.is_error()) {
-			const error &error = n_err.error();
+			const error &error = n_err.get_error();
 			if (error.is_critical()) {
 				if (write_done) {
 					write_done->fail(error.copy_error());
@@ -75,7 +75,7 @@ void write_task_and_step_helper::write_step(output_stream &writer) {
 			break;
 		} else {
 			if (write_done) {
-				write_done->fail(critical_error("Write failed"));
+				write_done->fail(make_error<err::invalid_state>("Write failed"));
 			}
 			write_task = std::nullopt;
 		}
-- 
cgit v1.2.3