use std::error_code instead of system::error_code

doc/modules/ROOT/pages/3.messages/3b.serializing.adoc

@@ -36,7 +36,7 @@ while (!sr.is_done())
 {
     auto result = sr.prepare();
     if (!result)
-        throw system::system_error(result.error());
+        throw std::system_error(result.error());
 
     co_await socket.write(*result);
     sr.consume(capy::buffer_size(*result));
@@ -260,7 +260,7 @@ while (!sr.is_done())
     }
 
     if (!result)
-        throw system::system_error(result.error());
+        throw std::system_error(result.error());
 
     co_await socket.write(*result);
     sr.consume(capy::buffer_size(*result));

doc/modules/ROOT/pages/3.messages/3c.parsing.adoc

@@ -58,7 +58,7 @@ auto buf = pr.prepare();
 std::size_t n = socket.read_some(buf);
 pr.commit(n);
 
-system::error_code ec;
+std::error_code ec;
 pr.parse(ec);
 
 // 6. Check result
@@ -120,11 +120,11 @@ while (!pr.got_header())
     std::size_t n = socket.read_some(buf);
     pr.commit(n);
 
-    system::error_code ec;
+    std::error_code ec;
     pr.parse(ec);
 
     if (ec && ec != condition::need_more_input)
-        throw system::system_error(ec);
+        throw std::system_error(ec);
 }
 
 // Access the parsed request
@@ -152,10 +152,10 @@ while (!pr.is_complete())
     std::size_t n = socket.read_some(buf);
     pr.commit(n);
 
-    system::error_code ec;
+    std::error_code ec;
     pr.parse(ec);
     if (ec && ec != condition::need_more_input)
-        throw system::system_error(ec);
+        throw std::system_error(ec);
 }
 
 // Access the complete body
@@ -176,10 +176,10 @@ while (!pr.is_complete())
     std::size_t n = socket.read_some(buf);
     pr.commit(n);
 
-    system::error_code ec;
+    std::error_code ec;
     pr.parse(ec);
     if (ec && ec != condition::need_more_input)
-        throw system::system_error(ec);
+        throw std::system_error(ec);
 
     // Process available body data
     auto body_bufs = pr.pull_body();
@@ -252,13 +252,13 @@ while (connection_open)
         }
         pr.commit(n);
 
-        system::error_code ec;
+        std::error_code ec;
         pr.parse(ec);
 
         if (ec == error::end_of_stream)
             break;  // Clean connection close
         if (ec && ec != condition::need_more_input)
-            throw system::system_error(ec);
+            throw std::system_error(ec);
     }
 
     // Process the request
@@ -268,11 +268,11 @@ while (connection_open)
 
 == Error Handling
 
-The parser reports errors through `system::error_code`:
+The parser reports errors through `std::error_code`:
 
 [source,cpp]
 ----
-system::error_code ec;
+std::error_code ec;
 pr.parse(ec);
 
 if (ec == condition::need_more_input)

doc/modules/ROOT/pages/4.servers/4b.route-handlers.adoc

@@ -111,7 +111,7 @@ And for errors:
 
 [source,cpp]
 ----
-co_return route_error(ec);  // from a system::error_code
+co_return route_error(ec);  // from a std::error_code
 ----
 
 These five outcomes cover every situation a handler can encounter. Most
@@ -620,7 +620,7 @@ takes two parameters:
 ----
 route_task my_error_handler(
     route_params& rp,
-    system::error_code ec)
+    std::error_code ec)
 {
     rp.status(status::internal_server_error);
     rp.res.set(field::content_type, "text/plain");
@@ -641,7 +641,7 @@ router.use(my_error_handler);
 
 // Error handler scoped to /api routes
 router.use("/api",
-    [](route_params& rp, system::error_code ec)
+    [](route_params& rp, std::error_code ec)
         -> route_task
     {
         rp.status(status::internal_server_error);
@@ -655,7 +655,7 @@ router.use("/api",
 The router distinguishes regular handlers from error handlers by
 inspecting their signature at compile time. A callable that accepts
 `(route_params&)` is a regular handler. A callable that accepts
-`(route_params&, system::error_code)` is an error handler. They
+`(route_params&, std::error_code)` is an error handler. They
 can coexist in the same `use()` call.
 
 === Error Propagation
@@ -669,7 +669,7 @@ processing:
 ----
 // Log the error, then pass it along
 router.use(
-    [](route_params& rp, system::error_code ec)
+    [](route_params& rp, std::error_code ec)
         -> route_task
     {
         std::cerr << "Error: " << ec.message() << "\n";
@@ -678,7 +678,7 @@ router.use(
 
 // Send a user-facing response
 router.use(
-    [](route_params& rp, system::error_code ec)
+    [](route_params& rp, std::error_code ec)
         -> route_task
     {
         rp.status(status::internal_server_error);
@@ -700,7 +700,7 @@ web frontend returns HTML:
 [source,cpp]
 ----
 router.use("/api",
-    [](route_params& rp, system::error_code ec)
+    [](route_params& rp, std::error_code ec)
         -> route_task
     {
         rp.status(status::internal_server_error);
@@ -711,7 +711,7 @@ router.use("/api",
     });
 
 router.use(
-    [](route_params& rp, system::error_code ec)
+    [](route_params& rp, std::error_code ec)
         -> route_task
     {
         rp.status(status::internal_server_error);

doc/modules/ROOT/pages/4.servers/4c.routers.adoc

@@ -556,7 +556,7 @@ api.add(method::get, "/fragile",
 router<> app;
 app.use("/api", std::move(api));
 app.use(
-    [](route_params& rp, system::error_code ec) -> route_task
+    [](route_params& rp, std::error_code ec) -> route_task
     {
         rp.status(status::internal_server_error);
         co_await rp.send("Error: " + ec.message());
@@ -771,7 +771,7 @@ An error handler is a callable with a specific signature:
 ----
 route_task handle_error(
     route_params& rp,
-    system::error_code ec)
+    std::error_code ec)
 {
     rp.status(status::internal_server_error);
     co_await rp.send("Error: " + ec.message());
@@ -781,7 +781,7 @@ route_task handle_error(
 
 The router distinguishes error handlers from regular handlers at
 compile time by inspecting the callable's parameter list. A callable
-that accepts `(route_params&, system::error_code)` is automatically
+that accepts `(route_params&, std::error_code)` is automatically
 treated as an error handler. No special registration method is needed
 -- you install them with the same `use()` that registers middleware:
 
@@ -808,7 +808,7 @@ An error handler can:
 ----
 // Log the error, then pass it along
 r.use(
-    [](route_params& rp, system::error_code ec)
+    [](route_params& rp, std::error_code ec)
         -> route_task
     {
         std::cerr << "Error: " << ec.message() << "\n";
@@ -817,7 +817,7 @@ r.use(
 
 // Send a response to the client
 r.use(
-    [](route_params& rp, system::error_code ec)
+    [](route_params& rp, std::error_code ec)
         -> route_task
     {
         rp.status(status::internal_server_error);
@@ -837,7 +837,7 @@ while the rest of the application returns HTML:
 [source,cpp]
 ----
 r.use("/api",
-    [](route_params& rp, system::error_code ec)
+    [](route_params& rp, std::error_code ec)
         -> route_task
     {
         rp.status(status::internal_server_error);
@@ -848,7 +848,7 @@ r.use("/api",
     });
 
 r.use(
-    [](route_params& rp, system::error_code ec)
+    [](route_params& rp, std::error_code ec)
         -> route_task
     {
         rp.status(status::internal_server_error);
@@ -1136,7 +1136,7 @@ app.use(serve_static("/var/www/public"));
 
 // Global error handler
 app.use(
-    [](route_params& rp, system::error_code ec)
+    [](route_params& rp, std::error_code ec)
         -> route_task
     {
         rp.status(status::internal_server_error);

doc/modules/ROOT/pages/4.servers/4g.bcrypt.adoc

@@ -36,7 +36,7 @@ bcrypt::result hash = bcrypt::hash("my_password", 12);
 // Store hash.str() in database...
 
 // Later, verify the password
-system::error_code ec;
+std::error_code ec;
 bool valid = bcrypt::compare("my_password", stored_hash, ec);
 
 if (ec)
@@ -112,7 +112,7 @@ the input password, and compares:
 
 [source,cpp]
 ----
-system::error_code ec;
+std::error_code ec;
 bool valid = bcrypt::compare(user_input, stored_hash, ec);
 
 if (ec == bcrypt::error::invalid_hash)
@@ -141,7 +141,7 @@ You can generate and use salts separately:
 bcrypt::result salt = bcrypt::gen_salt(12);
 
 // Hash with explicit salt
-system::error_code ec;
+std::error_code ec;
 bcrypt::result hash = bcrypt::hash("password", salt.str(), ec);
 ----
 
@@ -185,7 +185,7 @@ To check the cost factor of an existing hash:
 
 [source,cpp]
 ----
-system::error_code ec;
+std::error_code ec;
 unsigned rounds = bcrypt::get_rounds(stored_hash, ec);
 
 if (ec)
@@ -200,7 +200,7 @@ When a user logs in successfully, you can check if their hash needs upgrading:
 
 [source,cpp]
 ----
-system::error_code ec;
+std::error_code ec;
 bool valid = bcrypt::compare(password, stored_hash, ec);
 
 if (valid && !ec)

doc/modules/ROOT/pages/5.compression/5c.zstd.adoc

@@ -36,14 +36,14 @@ with `is_error` before using it:
 std::size_t n = compressor.compress(/* ... */);
 if (compressor.is_error(n))
 {
-    boost::system::error_code ec = compressor.get_error_code(n);
+    std::error_code ec = compressor.get_error_code(n);
     std::cerr << compressor.get_error_name(n) << '\n';
     return ec;
 }
 ----
 
-`zstd::error` is a Boost.System error enum, so an error code converts to
-`boost::system::error_code` and `std::error_code`.
+`zstd::error` is a standard error enum, so an error code converts to
+`std::error_code` and `std::error_code`.
 
 === One-Shot Compression
 

doc/modules/ROOT/pages/6.design/6a.sans-io.adoc

@@ -94,9 +94,9 @@ while (! in.empty())
 }
 pr.commit_eof();
 
-system::error_code ec;
+std::error_code ec;
 pr.parse(ec);
-BOOST_TEST(! ec.failed());
+BOOST_TEST(! ec);
 BOOST_TEST(pr.is_complete());
 BOOST_TEST_EQ(pr.get().status(), status::ok);
 ----

doc/modules/ROOT/pages/6.design/6b.parser.adoc

@@ -141,7 +141,7 @@ read_some(stream& s, parser& pr, error_code& ec)
         pr.commit_eof();
         ec = {};
     }
-    else if(ec.failed())
+    else if(ec)
     {
         return;
     }
@@ -158,8 +158,8 @@ read_header(stream& s, parser& pr)
         read_some(s, pr, ec);
         if(ec == condition::need_more_input)
             continue;
-        if(ec.failed())
-            throw system::system_error(ec);
+        if(ec)
+            throw std::system_error(ec);
     }
     while(! pr.got_header());
 }
@@ -173,8 +173,8 @@ read(stream& s, parser& pr)
         read_some(s, pr, ec);
         if(ec == condition::need_more_input)
             continue;
-        if(ec.failed())
-            throw system::system_error(ec);
+        if(ec)
+            throw std::system_error(ec);
     }
     while(! pr.is_complete());
 }