更新 src/Netra.cpp

README.md

@@ -34,3 +34,95 @@ c/c++基本开发库
 支持格式化输出
 
 
+# Http请求
+提供基于 `cpp-httplib` 的简易 HTTP 客户端封装 `NetRequest`，支持：
+1. 同步/异步 GET、POST（JSON、表单）
+2. 连接/读写超时设置、Keep-Alive
+3. 并发请求上限控制
+4. 可选内存缓存（GET 命中时不发起网络请求）
+5. 简单日志回调与性能统计
+6. 断点续传下载到本地文件
+
+使用步骤：
+
+1) 引入头文件，配置目标地址
+```cpp
+#include "NetRequest.hpp"
+
+ntq::RequestOptions opt;
+opt.scheme = "http";           // 或 https
+opt.host = "127.0.0.1";        // 服务器地址
+opt.port = 8080;                // 端口（https 一般 443）
+opt.base_path = "/api";        // 可选统一前缀
+opt.connect_timeout_ms = 3000;
+opt.read_timeout_ms    = 8000;
+opt.write_timeout_ms   = 8000;
+opt.default_headers = { {"Authorization", "Bearer TOKEN"} }; // 可选
+
+ntq::NetRequest req(opt);
+req.setMaxConcurrentRequests(4);
+req.enableCache(std::chrono::seconds(10));
+```
+
+2) 发送 GET 请求
+```cpp
+auto r = req.Get("/info");
+if (r && r->status == 200) {
+    // r->body 为返回内容
+}
+
+// 带查询参数与额外请求头
+httplib::Params q = {{"q","hello"},{"page","1"}};
+httplib::Headers h = {{"X-Req-Id","123"}};
+auto r2 = req.Get("/search", q, h);
+```
+
+3) 发送 POST 请求
+```cpp
+// JSON（Content-Type: application/json）
+std::string json = R"({"name":"orangepi","mode":"demo"})";
+auto p1 = req.PostJson("/set", json);
+
+// 表单（application/x-www-form-urlencoded）
+httplib::Params form = {{"user","abc"},{"pwd","123"}};
+auto p2 = req.PostForm("/login", form);
+```
+
+4) 异步调用
+```cpp
+auto fut = req.GetAsync("/info");
+auto res = fut.get(); // 与同步用法一致
+```
+
+5) 下载到本地（支持断点续传）
+```cpp
+bool ok = req.DownloadToFile("/files/pkg.bin", "/tmp/pkg.bin", {}, /*resume*/true);
+```
+
+6) 统计信息
+```cpp
+auto s = req.getStats();
+// s.total_requests / s.total_errors / s.last_latency_ms / s.avg_latency_ms
+```
+
+说明：
+- 若使用 HTTPS，需在编译时添加 `-DCPPHTTPLIB_OPENSSL_SUPPORT` 并链接 `-lssl -lcrypto`，且将 `opt.scheme` 设为 `"https"`、端口通常为 `443`。
+- `base_path` 与各函数传入的 `path` 会自动合并，例如 `base_path="/api"` 且 `Get("/info")` 实际请求路径为 `/api/info`。
+
+7) 快速用法（无需实例化）
+```cpp
+using ntq::NetRequest;
+
+// 直接传完整 URL 发起 GET
+auto g = NetRequest::QuickGet("http://127.0.0.1:8080/api/info");
+
+// 直接传完整 URL 发起 POST(JSON)
+auto p1 = NetRequest::QuickPostJson(
+    "http://127.0.0.1:8080/api/set",
+    R"({"name":"orangepi","mode":"demo"})"
+);
+
+// 直接传完整 URL 发起 POST(表单)
+httplib::Params form = {{"user","abc"},{"pwd","123"}};
+auto p2 = NetRequest::QuickPostForm("http://127.0.0.1:8080/login", form);
+```

include/NetRequest.hpp

@@ -20,10 +20,96 @@
 #include "httplib.h"
 #include <string>
 #include <functional>
-#include <optional>
 #include <future>
 #include <chrono>
 
+// C++17/14 可选类型回退适配：统一使用 ntq::optional / ntq::nullopt
+#if defined(__has_include)
+  #if __has_include(<optional>)
+    #include <optional>
+    // 仅当启用了 C++17 或库声明了 optional 功能时，才使用 std::optional
+    #if defined(__cpp_lib_optional) || (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+      namespace ntq { template <typename T> using optional = std::optional<T>; }
+      namespace ntq { constexpr auto nullopt = std::nullopt; using nullopt_t = decltype(std::nullopt); }
+    #elif __has_include(<experimental/optional>)
+      #include <experimental/optional>
+      namespace ntq { template <typename T> using optional = std::experimental::optional<T>; }
+      namespace ntq { constexpr auto nullopt = std::experimental::nullopt; using nullopt_t = decltype(std::experimental::nullopt); }
+    #else
+      #include <utility>
+      namespace ntq {
+        struct nullopt_t { explicit constexpr nullopt_t(int) {} };
+        static constexpr nullopt_t nullopt{0};
+        template <typename T>
+        class optional {
+        public:
+            optional() : has_(false) {}
+            optional(nullopt_t) : has_(false) {}
+            optional(const T &v) : has_(true), value_(v) {}
+            optional(T &&v) : has_(true), value_(std::move(v)) {}
+            optional(const optional &o) : has_(o.has_), value_(o.has_ ? o.value_ : T{}) {}
+            optional(optional &&o) noexcept : has_(o.has_), value_(std::move(o.value_)) {}
+            optional &operator=(nullopt_t) { has_ = false; return *this; }
+            optional &operator=(const T &v) { value_ = v; has_ = true; return *this; }
+            optional &operator=(T &&v) { value_ = std::move(v); has_ = true; return *this; }
+            explicit operator bool() const { return has_; }
+            bool has_value() const { return has_; }
+            T &value() { return value_; }
+            const T &value() const { return value_; }
+            T &operator*() { return value_; }
+            const T &operator*() const { return value_; }
+        private:
+            bool has_ = false;
+            T value_{};
+        };
+      }
+    #endif
+  #elif __has_include(<experimental/optional>)
+    #include <experimental/optional>
+    namespace ntq { template <typename T> using optional = std::experimental::optional<T>; }
+    namespace ntq { constexpr auto nullopt = std::experimental::nullopt; using nullopt_t = decltype(std::experimental::nullopt); }
+  #else
+    #include <utility>
+    namespace ntq {
+      struct nullopt_t { explicit constexpr nullopt_t(int) {} };
+      static constexpr nullopt_t nullopt{0};
+      template <typename T>
+      class optional {
+      public:
+          optional() : has_(false) {}
+          optional(nullopt_t) : has_(false) {}
+          optional(const T &v) : has_(true), value_(v) {}
+          optional(T &&v) : has_(true), value_(std::move(v)) {}
+          optional(const optional &o) : has_(o.has_), value_(o.has_ ? o.value_ : T{}) {}
+          optional(optional &&o) noexcept : has_(o.has_), value_(std::move(o.value_)) {}
+          optional &operator=(nullopt_t) { has_ = false; return *this; }
+          optional &operator=(const T &v) { value_ = v; has_ = true; return *this; }
+          optional &operator=(T &&v) { value_ = std::move(v); has_ = true; return *this; }
+          explicit operator bool() const { return has_; }
+          bool has_value() const { return has_; }
+          T &value() { return value_; }
+          const T &value() const { return value_; }
+          T &operator*() { return value_; }
+          const T &operator*() const { return value_; }
+      private:
+          bool has_ = false;
+          T value_{};
+      };
+    }
+  #endif
+#else
+  // 无 __has_include：按语言级别判断
+  #if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+    #include <optional>
+    namespace ntq { template <typename T> using optional = std::optional<T>; }
+    namespace ntq { constexpr auto nullopt = std::nullopt; using nullopt_t = decltype(std::nullopt); }
+  #else
+    #include <experimental/optional>
+    namespace ntq { template <typename T> using optional = std::experimental::optional<T>; }
+    namespace ntq { constexpr auto nullopt = std::experimental::nullopt; using nullopt_t = decltype(std::experimental::nullopt); }
+  #endif
+#endif
+
 namespace ntq
 {
     ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -137,7 +223,7 @@ namespace ntq
          * @param err 可选错误码输出
          * @return 成功返回响应对象，失败返回 std::nullopt
          */
-        std::optional<HttpResponse> Get(const std::string &path,
+        ntq::optional<HttpResponse> Get(const std::string &path,
                                         const httplib::Params &query = {},
                                         const httplib::Headers &headers = {},
                                         ErrorCode *err = nullptr);
@@ -150,7 +236,7 @@ namespace ntq
          * @param err 可选错误码输出
          * @return 成功返回响应对象，失败返回 std::nullopt
          */
-        std::optional<HttpResponse> PostJson(const std::string &path,
+        ntq::optional<HttpResponse> PostJson(const std::string &path,
                                              const std::string &json,
                                              const httplib::Headers &headers = {},
                                              ErrorCode *err = nullptr);
@@ -163,7 +249,7 @@ namespace ntq
          * @param err 可选错误码输出
          * @return 成功返回响应对象，失败返回 std::nullopt
          */
-        std::optional<HttpResponse> PostForm(const std::string &path,
+        ntq::optional<HttpResponse> PostForm(const std::string &path,
                                              const httplib::Params &form,
                                              const httplib::Headers &headers = {},
                                              ErrorCode *err = nullptr);
@@ -172,7 +258,7 @@ namespace ntq
          * @brief 异步 GET 请求
          * @return std::future，用于获取响应结果
          */
-        std::future<std::optional<HttpResponse>> GetAsync(const std::string &path,
+        std::future<ntq::optional<HttpResponse>> GetAsync(const std::string &path,
                                                           const httplib::Params &query = {},
                                                           const httplib::Headers &headers = {},
                                                           ErrorCode *err = nullptr);
@@ -181,7 +267,7 @@ namespace ntq
          * @brief 异步 POST JSON 请求
          * @return std::future，用于获取响应结果
          */
-        std::future<std::optional<HttpResponse>> PostJsonAsync(const std::string &path,
+        std::future<ntq::optional<HttpResponse>> PostJsonAsync(const std::string &path,
                                                                const std::string &json,
                                                                const httplib::Headers &headers = {},
                                                                ErrorCode *err = nullptr);
@@ -190,7 +276,7 @@ namespace ntq
          * @brief 异步 POST 表单请求
          * @return std::future，用于获取响应结果
          */
-        std::future<std::optional<HttpResponse>> PostFormAsync(const std::string &path,
+        std::future<ntq::optional<HttpResponse>> PostFormAsync(const std::string &path,
                                                                const httplib::Params &form,
                                                                const httplib::Headers &headers = {},
                                                                ErrorCode *err = nullptr);
@@ -217,6 +303,40 @@ namespace ntq
          */
         Stats getStats() const;
 
+        /**
+         * @brief 便捷：直接用完整 URL 发起 GET（无需显式实例化）
+         * @param url 形如 http://host:port/path?x=1 或 https://host/path
+         * @param headers 额外头部
+         * @param err 可选错误码输出
+         */
+        static ntq::optional<HttpResponse> QuickGet(const std::string &url,
+                                                    const httplib::Headers &headers = {},
+                                                    ErrorCode *err = nullptr);
+
+        /**
+         * @brief 便捷：直接用完整 URL 发起 POST JSON（无需显式实例化）
+         * @param url 形如 http://host:port/path?x=1 或 https://host/path
+         * @param json JSON 字符串（Content-Type: application/json）
+         * @param headers 额外头部
+         * @param err 可选错误码输出
+         */
+        static ntq::optional<HttpResponse> QuickPostJson(const std::string &url,
+                                                         const std::string &json,
+                                                         const httplib::Headers &headers = {},
+                                                         ErrorCode *err = nullptr);
+
+        /**
+         * @brief 便捷：直接用完整 URL 发起 POST 表单（无需显式实例化）
+         * @param url 形如 http://host:port/path?x=1 或 https://host/path
+         * @param form 表单参数
+         * @param headers 额外头部
+         * @param err 可选错误码输出
+         */
+        static ntq::optional<HttpResponse> QuickPostForm(const std::string &url,
+                                                         const httplib::Params &form,
+                                                         const httplib::Headers &headers = {},
+                                                         ErrorCode *err = nullptr);
+
     private:
         struct Impl;
         Impl *impl_;

include/Netra.hpp

@@ -1,411 +1,501 @@
-#pragma once
+#pragma once
-#include "QCL_Include.hpp"
+#include "QCL_Include.hpp"
-
+
-namespace QCL
+namespace QCL
-{
+{
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-    /**
+    /**
-     * @class TcpServer
+     * @class TcpServer
-     * @brief 简单的多线程TCP服务器类，支持多个客户端连接，数据收发及断开处理
+     * @brief 简单的多线程TCP服务器类，支持多个客户端连接，数据收发及断开处理
-     *
+     *
-     * 该类使用一个线程专门用于监听客户端连接，
+     * 该类使用一个线程专门用于监听客户端连接，
-     * 每当有客户端连接成功时，为其创建一个独立线程处理该客户端的数据收发。
+     * 每当有客户端连接成功时，为其创建一个独立线程处理该客户端的数据收发。
-     * 线程安全地管理所有客户端Socket句柄。
+     * 线程安全地管理所有客户端Socket句柄。
-     */
+     */
-    class TcpServer
+    class TcpServer
-    {
+    {
-    public:
+    public:
-        /**
+        /**
-         * @brief 构造函数，指定监听端口
+         * @brief 构造函数，指定监听端口
-         * @param port 服务器监听端口号
+         * @param port 服务器监听端口号
-         */
+         */
-        TcpServer(int port);
+        TcpServer(int port);
-
+
-        /**
+        /**
-         * @brief 析构函数，自动调用 stop() 停止服务器并清理资源
+         * @brief 析构函数，自动调用 stop() 停止服务器并清理资源
-         */
+         */
-        ~TcpServer();
+        ~TcpServer();
-
+
-        /**
+        /**
-         * @brief 启动服务器，创建监听socket，开启监听线程
+         * @brief 启动服务器，创建监听socket，开启监听线程
-         * @return 启动成功返回true，失败返回false
+         * @return 启动成功返回true，失败返回false
-         */
+         */
-        bool start();
+        bool start();
-
+
-        /**
+        /**
-         * @brief 停止服务器，关闭所有连接，释放资源，等待所有线程退出
+         * @brief 停止服务器，关闭所有连接，释放资源，等待所有线程退出
-         */
+         */
-        void stop();
+        void stop();
-
+
-        /**
+        /**
-         * @brief 发送消息给指定客户端
+         * @brief 发送消息给指定客户端
-         * @param clientSock 客户端Socket描述符
+         * @param clientSock 客户端Socket描述符
-         * @param message 发送的字符串消息
+         * @param message 发送的字符串消息
-         */
+         */
-        void sendToClient(int clientSock, const std::string &message);
+        void sendToClient(int clientSock, const std::string &message);
-
+
-        /**
+        /**
-         * @brief 从指定客户端接收数据（单次调用）
+         * @brief 从指定客户端接收数据（单次调用）
-         * @param clientSock 客户端Socket描述符
+         * @param clientSock 客户端Socket描述符
-         * @param flag:false 非阻塞模式,true 阻塞模式
+         * @param flag:false 非阻塞模式,true 阻塞模式
-         */
+         */
-        std::string receiveFromClient(int clientSock, bool flag = true);
+        std::string receiveFromClient(int clientSock, bool flag = true);
-
+
-        /**
+        /**
-         * @brief 获取连接客户端的IP和端口
+         * @brief 获取连接客户端的IP和端口
-         * @param clientSock 客户端Socket描述符
+         * @param clientSock 客户端Socket描述符
-         */
+         */
-        char *getClientIPAndPort(int clientSock);
+        char *getClientIPAndPort(int clientSock);
-
+
-        /**
+        /**
-         * @brief 获取当前所有已连接客户端Socket的副本
+         * @brief 从服务器的客户端列表中移除并关闭一个客户端socket
-         * @return 包含所有客户端Socket的vector，线程安全
+         * @param clientSock 客户端Socket描述符
-         */
+         */
-        std::vector<int> getClientSockets();
+        void removeClient(int clientSock);
-
+        
-    private:
+        /**
-        /**
+         * @brief 非阻塞探测客户端是否已断开（不消耗数据）
-         * @brief 监听并接受新的客户端连接（运行在独立线程中）
+         * @param clientSock 客户端Socket描述符
-         */
+         * @return true 已断开或发生致命错误；false 仍然存活或暂无数据
-        void acceptClients();
+         */
-
+        bool isClientDisconnected(int clientSock);
-    private:
+
-        int serverSock_;                         ///< 服务器监听Socket描述符
+        /**
-        int port_;                               ///< 服务器监听端口
+         * @brief 获取当前所有已连接客户端Socket的副本
-        std::atomic<bool> running_;              ///< 服务器运行状态标志（线程安全）
+         * @return 包含所有客户端Socket的vector，线程安全
-        std::vector<std::thread> clientThreads_; ///< 用于处理每个客户端的线程集合
+         */
-        std::thread acceptThread_;               ///< 负责监听新连接的线程
+        std::vector<int> getClientSockets();
-        std::mutex clientsMutex_;                ///< 保护clientSockets_的互斥锁
+
-        std::vector<int> clientSockets_;         ///< 当前所有连接的客户端Socket集合
+    private:
-    };
+        /**
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         * @brief 监听并接受新的客户端连接（运行在独立线程中）
-    /**
+         */
-     * @brief 文件写入工具类（线程安全）
+        void acceptClients();
-     *
+
-     * 该类支持多种文件写入方式：
+    private:
-     *  - 覆盖写文本
+        int serverSock_;                         ///< 服务器监听Socket描述符
-     *  - 追加写文本
+        int port_;                               ///< 服务器监听端口
-     *  - 按位置覆盖原文写入
+        std::atomic<bool> running_;              ///< 服务器运行状态标志（线程安全）
-     *  - 二进制覆盖写
+        std::vector<std::thread> clientThreads_; ///< 用于处理每个客户端的线程集合
-     *  - 二进制追加写
+        std::thread acceptThread_;               ///< 负责监听新连接的线程
-     *
+        std::mutex clientsMutex_;                ///< 保护clientSockets_的互斥锁
-     * 特点：
+        std::vector<int> clientSockets_;         ///< 当前所有连接的客户端Socket集合
-     *  - 文件不存在时自动创建
+    };
-     *  - 支持覆盖和追加两种模式
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-     *  - 支持二进制模式，适合写入非文本数据
+    /**
-     *  - 内部使用 std::mutex 实现线程安全
+     * @class TcpClient
-     */
+     * @brief 简单的TCP客户端类，支持自动连接、消息收发及断线重连
-    class WriteFile
+     *
-    {
+     * 该类用于连接指定服务器IP与端口，
-    public:
+     * 支持发送与接收字符串消息，
-        /**
+     * 并提供自动重连与线程安全的消息接收。
-         * @brief 构造函数
+     */
-         * @param filePath 文件路径
+    class TcpClient
-         */
+    {
-        explicit WriteFile(const std::string &filePath);
+    public:
-
+        /**
-        /**
+         * @brief 构造函数，指定服务器IP与端口
-         * @brief 覆盖写文本文件（线程安全）
+         * @param serverIP 服务器IP地址
-         * @param content 要写入的文本内容
+         * @param serverPort 服务器端口号
-         * @return true 写入成功
+         */
-         * @return false 写入失败
+        TcpClient(const std::string &serverIP, int serverPort);
-         */
+
-        bool overwriteText(const std::string &content);
+        /**
-
+         * @brief 析构函数，自动断开连接并清理资源
-        /**
+         */
-         * @brief 追加写文本文件（线程安全）
+        ~TcpClient();
-         * @param content 要写入的文本内容
+
-         * @return true 写入成功
+        /**
-         * @return false 写入失败
+         * @brief 连接服务器
-         */
+         * @return 连接成功返回true，失败返回false
-        bool appendText(const std::string &content);
+         */
-
+        bool connectToServer();
-        /**
+
-         * @brief 覆盖写二进制文件（线程安全）
+        /**
-         * @param data 要写入的二进制数据
+         * @brief 断开与服务器的连接
-         * @return true 写入成功
+         */
-         * @return false 写入失败
+        void disconnect();
-         */
+
-        bool overwriteBinary(const std::vector<char> &data);
+        /**
-
+         * @brief 向服务器发送字符串消息
-        /**
+         * @param message 要发送的字符串
-         * @brief 追加写二进制文件（线程安全）
+         */
-         * @param data 要写入的二进制数据
+        void sendToServer(const std::string &message);
-         * @return true 写入成功
+
-         * @return false 写入失败
+        /**
-         */
+         * @brief 从服务器接收数据（单次调用）
-        bool appendBinary(const std::vector<char> &data);
+         * @param flag false: 非阻塞模式, true: 阻塞模式
-
+         * @return 收到的数据字符串（若无数据返回空字符串）
-        /**
+         */
-         * @brief 计算第一个指定字节序列前的字节数
+        std::string receiveFromServer(bool flag = true);
-         * @param pattern 要查找的字节序列
+
-         * @param includePattern true 表示返回值包含 pattern 自身长度，false 表示不包含
+        /**
-         * @return size_t 字节数，如果文件没打开或 pattern 为空则返回 0
+         * @brief 获取当前连接的服务器IP和端口
-         */
+         * @return 字符串形式的 "IP:Port"
-        size_t countBytesPattern(const std::string &pattern, bool includePattern = false);
+         */
-
+        std::string getServerIPAndPort() const;
-        /**
+
-         * @brief 在文件中查找指定字节序列并在其后写入内容，如果不存在则追加到文件末尾
+        /**
-         * @param pattern 要查找的字节序列
+         * @brief 判断客户端当前是否已连接
-         * @param content 要写入的内容
+         * @return 已连接返回true，否则返回false
-         * @return true 写入成功，false 文件打开失败
+         */
-         *
+        bool isConnected() const;
-         * 功能说明：
+
-         * 1. 若文件中存在 pattern，则删除 pattern 之后的所有内容，并在其后插入 content。
+    private:
-         * 2. 若文件中不存在 pattern，则在文件末尾追加 content，若末尾无换行符则先补充换行。
+        /**
-         */
+         * @brief 尝试自动重连服务器（可选）
-        bool writeAfterPatternOrAppend(const std::string &pattern, const std::string &content);
+         * @param retryIntervalMs 重连间隔，单位毫秒
-
+         */
-        /**
+        void reconnectLoop(int retryIntervalMs = 3000);
-         * @brief 在文件指定位置之后插入内容
+
-         * @param content 要插入的内容
+    private:
-         * @param pos 插入位置（从文件开头算起的字节偏移量）
+        int clientSock_;                 ///< 客户端Socket描述符
-         * @param length 插入的长度（>= content.size() 时，多余部分用空字节填充；< content.size() 时只截取前 length 个字节）
+        std::string serverIP_;           ///< 服务器IP地址
-         * @return true 插入成功，false 文件打开失败或参数不合法
+        int serverPort_;                 ///< 服务器端口号
-         *
+        std::atomic<bool> connected_;    ///< 连接状态标志（线程安全）
-         * 功能说明：
+        std::atomic<bool> running_;      ///< 是否保持运行（用于自动重连）
-         * 1. 不会覆盖原有数据，而是将 pos 之后的内容整体向后移动 length 个字节。
+        std::thread reconnectThread_;    ///< 自动重连线程（可选）
-         * 2. 如果 length > content.size()，则在 content 后补充 '\0'（或空格，可按需求改）。
+        mutable std::mutex socketMutex_; ///< 保护socket的互斥锁
-         * 3. 如果 length < content.size()，则只写入 content 的前 length 个字节。
+    };
-         * 4. 文件整体大小会增加 length 个字节。
+
-         *
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         * 举例：
+    /**
-         * 原始文件内容: "ABCDEFG"
+     * @brief 文件写入工具类（线程安全）
-         * insertAfterPos("XY", 2, 3)  // 在索引 2 后插入
+     *
-         * 结果: "ABX Y\0CDEFG"   (这里 \0 代表补充的空字节)
+     * 该类支持多种文件写入方式：
-         */
+     *  - 覆盖写文本
-        bool insertAfterPos(const std::string &content, size_t pos, size_t length);
+     *  - 追加写文本
-
+     *  - 按位置覆盖原文写入
-        /**
+     *  - 二进制覆盖写
-         * @brief 在文件指定位置覆盖写入内容
+     *  - 二进制追加写
-         * @param content 要写入的内容
+     *
-         * @param pos 覆盖起始位置（从文件开头算起的字节偏移量）
+     * 特点：
-         * @param length 覆盖长度
+     *  - 文件不存在时自动创建
-         * @return true 覆盖成功，false 文件打开失败或 pos 越界
+     *  - 支持覆盖和追加两种模式
-         *
+     *  - 支持二进制模式，适合写入非文本数据
-         * 功能说明：
+     *  - 内部使用 std::mutex 实现线程安全
-         * 1. 从 pos 开始覆盖 length 个字节，不会移动或增加文件大小。
+     */
-         * 2. 如果 content.size() >= length，则只写入前 length 个字节。
+    class WriteFile
-         * 3. 如果 content.size() < length，则写入 content，并用 '\0' 补齐至 length。
+    {
-         * 4. 如果 pos + length 超过文件末尾，则只覆盖到文件尾部，不会越界。
+    public:
-         *
+        /**
-         * 举例：
+         * @brief 构造函数
-         * 原始文件内容: "ABCDEFG"
+         * @param filePath 文件路径
-         * overwriteAtPos("XY", 2, 3)
+         */
-         * 结果: "ABXYEFG"   （原 "CDE" 被 "XY\0" 覆盖，\0 实际不可见）
+        explicit WriteFile(const std::string &filePath);
-         */
+
-        bool overwriteAtPos(const std::string &content, size_t pos, size_t length);
+        /**
-
+         * @brief 覆盖写文本文件（线程安全）
-    private:
+         * @param content 要写入的文本内容
-        std::string filePath_;  ///< 文件路径
+         * @return true 写入成功
-        std::mutex writeMutex_; ///< 线程锁，保证多线程写入安全
+         * @return false 写入失败
-
+         */
-        /**
+        bool overwriteText(const std::string &content);
-         * @brief 通用文本写入接口（线程安全）
+
-         * @param content 要写入的内容
+        /**
-         * @param mode 打开模式（追加/覆盖等）
+         * @brief 追加写文本文件（线程安全）
-         * @return true 写入成功
+         * @param content 要写入的文本内容
-         * @return false 写入失败
+         * @return true 写入成功
-         */
+         * @return false 写入失败
-        bool writeToFile(const std::string &content, std::ios::openmode mode);
+         */
-
+        bool appendText(const std::string &content);
-        /**
+
-         * @brief 通用二进制写入接口（线程安全）
+        /**
-         * @param data 要写入的二进制数据
+         * @brief 覆盖写二进制文件（线程安全）
-         * @param mode 打开模式（追加/覆盖等）
+         * @param data 要写入的二进制数据
-         * @return true 写入成功
+         * @return true 写入成功
-         * @return false 写入失败
+         * @return false 写入失败
-         */
+         */
-        bool writeBinary(const std::vector<char> &data, std::ios::openmode mode);
+        bool overwriteBinary(const std::vector<char> &data);
-    };
+
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+        /**
-    /**
+         * @brief 追加写二进制文件（线程安全）
-     * @brief ReadFile 类 - 读文件操作工具类
+         * @param data 要写入的二进制数据
-     *
+         * @return true 写入成功
-     * 功能：
+         * @return false 写入失败
-     *  1. 读取全文（文本 / 二进制）
+         */
-     *  2. 按行读取
+        bool appendBinary(const std::vector<char> &data);
-     *  3. 按字节数读取
+
-     *  4. 获取指定字节序列前的字节数（包含该字节序列）
+        /**
-     *  5. 检查文件是否存在
+         * @brief 计算第一个指定字节序列前的字节数
-     *  6. 获取文件大小
+         * @param pattern 要查找的字节序列
-     *
+         * @param includePattern true 表示返回值包含 pattern 自身长度，false 表示不包含
-     * 设计：
+         * @return size_t 字节数，如果文件没打开或 pattern 为空则返回 0
-     *  - 与 WriteFile 类风格保持一致
+         */
-     *  - 支持文本文件与二进制文件
+        size_t countBytesPattern(const std::string &pattern, bool includePattern = false);
-     *  - 自动关闭文件（析构时）
+
-     *  - 内部使用 std::mutex 实现线程安全
+        /**
-     */
+         * @brief 在文件中查找指定字节序列并在其后写入内容，如果不存在则追加到文件末尾
-    class ReadFile
+         * @param pattern 要查找的字节序列
-    {
+         * @param content 要写入的内容
-    public:
+         * @return true 写入成功，false 文件打开失败
-        /**
+         *
-         * @brief 构造函数
+         * 功能说明：
-         * @param filename 文件路径
+         * 1. 若文件中存在 pattern，则删除 pattern 之后的所有内容，并在其后插入 content。
-         */
+         * 2. 若文件中不存在 pattern，则在文件末尾追加 content，若末尾无换行符则先补充换行。
-        explicit ReadFile(const std::string &filename);
+         */
-
+        bool writeAfterPatternOrAppend(const std::string &pattern, const std::string &content);
-        /**
+
-         * @brief 析构函数，自动关闭文件
+        /**
-         */
+         * @brief 在文件指定位置之后插入内容
-        ~ReadFile();
+         * @param content 要插入的内容
-
+         * @param pos 插入位置（从文件开头算起的字节偏移量）
-        /**
+         * @param length 插入的长度（>= content.size() 时，多余部分用空字节填充；< content.size() 时只截取前 length 个字节）
-         * @brief 打开文件（以二进制方式）
+         * @return true 插入成功，false 文件打开失败或参数不合法
-         * @return true 打开成功
+         *
-         * @return false 打开失败
+         * 功能说明：
-         */
+         * 1. 不会覆盖原有数据，而是将 pos 之后的内容整体向后移动 length 个字节。
-        bool Open();
+         * 2. 如果 length > content.size()，则在 content 后补充 '\0'（或空格，可按需求改）。
-
+         * 3. 如果 length < content.size()，则只写入 content 的前 length 个字节。
-        /**
+         * 4. 文件整体大小会增加 length 个字节。
-         * @brief 关闭文件
+         *
-         */
+         * 举例：
-        void Close();
+         * 原始文件内容: "ABCDEFG"
-
+         * insertAfterPos("XY", 2, 3)  // 在索引 2 后插入
-        /**
+         * 结果: "ABX Y\0CDEFG"   (这里 \0 代表补充的空字节)
-         * @brief 文件是否已经打开
+         */
-         */
+        bool insertAfterPos(const std::string &content, size_t pos, size_t length);
-        bool IsOpen() const;
+
-
+        /**
-        /**
+         * @brief 在文件指定位置覆盖写入内容
-         * @brief 读取全文（文本模式）
+         * @param content 要写入的内容
-         * @return 文件内容字符串
+         * @param pos 覆盖起始位置（从文件开头算起的字节偏移量）
-         */
+         * @param length 覆盖长度
-        std::string ReadAllText();
+         * @return true 覆盖成功，false 文件打开失败或 pos 越界
-
+         *
-        /**
+         * 功能说明：
-         * @brief 读取全文（二进制模式）
+         * 1. 从 pos 开始覆盖 length 个字节，不会移动或增加文件大小。
-         * @return 文件内容字节数组
+         * 2. 如果 content.size() >= length，则只写入前 length 个字节。
-         */
+         * 3. 如果 content.size() < length，则写入 content，并用 '\0' 补齐至 length。
-        std::vector<char> ReadAllBinary();
+         * 4. 如果 pos + length 超过文件末尾，则只覆盖到文件尾部，不会越界。
-
+         *
-        /**
+         * 举例：
-         * @brief 按行读取文本
+         * 原始文件内容: "ABCDEFG"
-         * @return 每行作为一个字符串的 vector
+         * overwriteAtPos("XY", 2, 3)
-         */
+         * 结果: "ABXYEFG"   （原 "CDE" 被 "XY\0" 覆盖，\0 实际不可见）
-        std::vector<std::string> ReadLines();
+         */
-
+        bool overwriteAtPos(const std::string &content, size_t pos, size_t length);
-        /**
+
-         * @brief 读取指定字节数
+    private:
-         * @param count 要读取的字节数
+        std::string filePath_;  ///< 文件路径
-         * @return 实际读取到的字节数据
+        std::mutex writeMutex_; ///< 线程锁，保证多线程写入安全
-         */
+
-        std::vector<char> ReadBytes(size_t count);
+        /**
-
+         * @brief 通用文本写入接口（线程安全）
-        /**
+         * @param content 要写入的内容
-         * @brief 获取指定字节序列前的字节数（包含该字节序列）
+         * @param mode 打开模式（追加/覆盖等）
-         * @param marker 要查找的字节序列（可能不止一个字节）
+         * @return true 写入成功
-         * @return 如果找到，返回前面部分字节数；找不到返回0
+         * @return false 写入失败
-         */
+         */
-        size_t GetBytesBefore(const std::string &marker, bool includeMarker = false);
+        bool writeToFile(const std::string &content, std::ios::openmode mode);
-
+
-        /**
+        /**
-         * @brief 从指定位置读取指定字节数，默认读取到文件末尾
+         * @brief 通用二进制写入接口（线程安全）
-         * @param pos 起始位置（字节偏移）
+         * @param data 要写入的二进制数据
-         * @param count 要读取的字节数，默认为0表示读取到文件末尾
+         * @param mode 打开模式（追加/覆盖等）
-         * @return 读取到的字节数据
+         * @return true 写入成功
-         */
+         * @return false 写入失败
-        std::vector<char> ReadBytesFrom(size_t pos, size_t count = 0);
+         */
-
+        bool writeBinary(const std::vector<char> &data, std::ios::openmode mode);
-        /**
+    };
-         * @brief 检查文件是否存在
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-         */
+    /**
-        bool FileExists() const;
+     * @brief ReadFile 类 - 读文件操作工具类
-
+     *
-        /**
+     * 功能：
-         * @brief 获取文件大小（字节数）
+     *  1. 读取全文（文本 / 二进制）
-         */
+     *  2. 按行读取
-        size_t GetFileSize() const;
+     *  3. 按字节数读取
-
+     *  4. 获取指定字节序列前的字节数（包含该字节序列）
-        /**
+     *  5. 检查文件是否存在
-         * @brief 重置读取位置到文件开头
+     *  6. 获取文件大小
-         */
+     *
-        void Reset();
+     * 设计：
-
+     *  - 与 WriteFile 类风格保持一致
-    private:
+     *  - 支持文本文件与二进制文件
-        std::string filename_;   // 文件路径
+     *  - 自动关闭文件（析构时）
-        std::ifstream file_;     // 文件流对象
+     *  - 内部使用 std::mutex 实现线程安全
-        mutable std::mutex mtx_; // 可变，保证 const 方法也能加锁
+     */
-    };
+    class ReadFile
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    {
-
+    public:
-    // 屏蔽所有信号
+        /**
-    void blockAllSignals();
+         * @brief 构造函数
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         * @param filename 文件路径
-    // 字符串操作
+         */
-    //  去除字符串的左空格
+        explicit ReadFile(const std::string &filename);
-    std::string Ltrim(const std::string &s);
+
-
+        /**
-    // 去除字符串右侧的空格
+         * @brief 析构函数，自动关闭文件
-    std::string Rtrim(const std::string &s);
+         */
-
+        ~ReadFile();
-    // 去除字符串左右两侧的空格
+
-    std::string LRtrim(const std::string &s);
+        /**
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+         * @brief 打开文件（以二进制方式）
-    // c++进行格式化输出
+         * @return true 打开成功
-    //  通用类型转字符串
+         * @return false 打开失败
-    template <typename T>
+         */
-    std::string to_string_any(const T &value)
+        bool Open();
-    {
+
-        std::ostringstream oss;
+        /**
-        oss << value;
+         * @brief 关闭文件
-        return oss.str();
+         */
-    }
+        void Close();
-
+
-    // 递归获取 tuple 中 index 对应参数
+        /**
-    template <std::size_t I = 0, typename Tuple>
+         * @brief 文件是否已经打开
-    std::string get_tuple_arg(const Tuple &tup, std::size_t index)
+         */
-    {
+        bool IsOpen() const;
-        if constexpr (I < std::tuple_size_v<Tuple>)
+
-        {
+        /**
-            if (I == index)
+         * @brief 读取全文（文本模式）
-                return to_string_any(std::get<I>(tup));
+         * @return 文件内容字符串
-            else
+         */
-                return get_tuple_arg<I + 1>(tup, index);
+        std::string ReadAllText();
-        }
+
-        else
+        /**
-        {
+         * @brief 读取全文（二进制模式）
-            throw std::runtime_error("Too few arguments for format string");
+         * @return 文件内容字节数组
-        }
+         */
-    }
+        std::vector<char> ReadAllBinary();
-
+
-    // format 函数
+        /**
-    template <typename... Args>
+         * @brief 按行读取文本
-    std::string format(const std::string &fmt, const Args &...args)
+         * @return 每行作为一个字符串的 vector
-    {
+         */
-        std::ostringstream oss;
+        std::vector<std::string> ReadLines();
-        std::tuple<const Args &...> tup(args...);
+
-        size_t pos = 0;
+        /**
-        size_t arg_idx = 0;
+         * @brief 读取指定字节数
-
+         * @param count 要读取的字节数
-        while (pos < fmt.size())
+         * @return 实际读取到的字节数据
-        {
+         */
-            if (fmt[pos] == '{' && pos + 1 < fmt.size() && fmt[pos + 1] == '{')
+        std::vector<char> ReadBytes(size_t count);
-            {
+
-                oss << '{';
+        /**
-                pos += 2;
+         * @brief 获取指定字节序列前的字节数（包含该字节序列）
-            }
+         * @param marker 要查找的字节序列（可能不止一个字节）
-            else if (fmt[pos] == '}' && pos + 1 < fmt.size() && fmt[pos + 1] == '}')
+         * @return 如果找到，返回前面部分字节数；找不到返回0
-            {
+         */
-                oss << '}';
+        size_t GetBytesBefore(const std::string &marker, bool includeMarker = false);
-                pos += 2;
+
-            }
+        /**
-            else if (fmt[pos] == '{' && pos + 1 < fmt.size() && fmt[pos + 1] == '}')
+         * @brief 从指定位置读取指定字节数，默认读取到文件末尾
-            {
+         * @param pos 起始位置（字节偏移）
-                oss << get_tuple_arg(tup, arg_idx++);
+         * @param count 要读取的字节数，默认为0表示读取到文件末尾
-                pos += 2;
+         * @return 读取到的字节数据
-            }
+         */
-            else
+        std::vector<char> ReadBytesFrom(size_t pos, size_t count = 0);
-            {
+
-                oss << fmt[pos++];
+        /**
-            }
+         * @brief 检查文件是否存在
-        }
+         */
-
+        bool FileExists() const;
-        if (arg_idx < sizeof...(Args))
+
-            throw std::runtime_error("Too many arguments for format string");
+        /**
-
+         * @brief 获取文件大小（字节数）
-        return oss.str();
+         */
-    }
+        size_t GetFileSize() const;
-    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
-
+        /**
-}
+         * @brief 重置读取位置到文件开头
+         */
+        void Reset();
+
+    private:
+        std::string filename_;   // 文件路径
+        std::ifstream file_;     // 文件流对象
+        mutable std::mutex mtx_; // 可变，保证 const 方法也能加锁
+    };
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+    // 屏蔽所有信号
+    void blockAllSignals();
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // 字符串操作
+    //  去除字符串的左空格
+    std::string Ltrim(const std::string &s);
+
+    // 去除字符串右侧的空格
+    std::string Rtrim(const std::string &s);
+
+    // 去除字符串左右两侧的空格
+    std::string LRtrim(const std::string &s);
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+    // c++进行格式化输出
+    //  通用类型转字符串
+    template <typename T>
+    std::string to_string_any(const T &value)
+    {
+        std::ostringstream oss;
+        oss << value;
+        return oss.str();
+    }
+
+    // 递归获取 tuple 中 index 对应参数
+    template <std::size_t I = 0, typename Tuple>
+    std::string get_tuple_arg(const Tuple &tup, std::size_t index)
+    {
+        if constexpr (I < std::tuple_size_v<Tuple>)
+        {
+            if (I == index)
+                return to_string_any(std::get<I>(tup));
+            else
+                return get_tuple_arg<I + 1>(tup, index);
+        }
+        else
+        {
+            throw std::runtime_error("Too few arguments for format string");
+        }
+    }
+
+    // format 函数
+    template <typename... Args>
+    std::string format(const std::string &fmt, const Args &...args)
+    {
+        std::ostringstream oss;
+        std::tuple<const Args &...> tup(args...);
+        size_t pos = 0;
+        size_t arg_idx = 0;
+
+        while (pos < fmt.size())
+        {
+            if (fmt[pos] == '{' && pos + 1 < fmt.size() && fmt[pos + 1] == '{')
+            {
+                oss << '{';
+                pos += 2;
+            }
+            else if (fmt[pos] == '}' && pos + 1 < fmt.size() && fmt[pos + 1] == '}')
+            {
+                oss << '}';
+                pos += 2;
+            }
+            else if (fmt[pos] == '{' && pos + 1 < fmt.size() && fmt[pos + 1] == '}')
+            {
+                oss << get_tuple_arg(tup, arg_idx++);
+                pos += 2;
+            }
+            else
+            {
+                oss << fmt[pos++];
+            }
+        }
+
+        if (arg_idx < sizeof...(Args))
+            throw std::runtime_error("Too many arguments for format string");
+
+        return oss.str();
+    }
+    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+}

include/encrypt.hpp

@@ -0,0 +1,14 @@
+#pragma once
+
+/*
+主要是用于各种加密
+*/
+
+#include "QCL_Include.hpp"
+
+using namespace std;
+
+namespace encrypt
+{
+    string MD5(const string &info);
+}

src/NetRequest.cpp

@@ -198,7 +198,7 @@ namespace ntq
         impl_->cache.clear();
     }
 
-    std::optional<HttpResponse> NetRequest::Get(const std::string &path,
+    ntq::optional<HttpResponse> NetRequest::Get(const std::string &path,
                                                 const httplib::Params &query,
                                                 const httplib::Headers &headers,
                                                 ErrorCode *err)
@@ -221,7 +221,7 @@ namespace ntq
             }
         }
 
-        std::optional<HttpResponse> result;
+        ntq::optional<HttpResponse> result;
         ErrorCode local_err = ErrorCode::None;
 
         const auto full_path = impl_->build_full_path(path);
@@ -280,7 +280,7 @@ namespace ntq
         {
             impl_->stats.total_errors++;
             if (err) *err = local_err;
-            return std::nullopt;
+            return ntq::nullopt;
         }
 
         if (impl_->cache_enabled)
@@ -293,7 +293,7 @@ namespace ntq
         return result;
     }
 
-    std::optional<HttpResponse> NetRequest::PostJson(const std::string &path,
+    ntq::optional<HttpResponse> NetRequest::PostJson(const std::string &path,
                                                      const std::string &json,
                                                      const httplib::Headers &headers,
                                                      ErrorCode *err)
@@ -302,7 +302,7 @@ namespace ntq
         impl_->stats.total_requests++;
         auto start = std::chrono::steady_clock::now();
 
-        std::optional<HttpResponse> result;
+        ntq::optional<HttpResponse> result;
         ErrorCode local_err = ErrorCode::None;
 
         const auto full_path = impl_->build_full_path(path);
@@ -349,13 +349,13 @@ namespace ntq
         {
             impl_->stats.total_errors++;
             if (err) *err = local_err;
-            return std::nullopt;
+            return ntq::nullopt;
         }
         if (err) *err = ErrorCode::None;
         return result;
     }
 
-    std::optional<HttpResponse> NetRequest::PostForm(const std::string &path,
+    ntq::optional<HttpResponse> NetRequest::PostForm(const std::string &path,
                                                      const httplib::Params &form,
                                                      const httplib::Headers &headers,
                                                      ErrorCode *err)
@@ -364,7 +364,7 @@ namespace ntq
         impl_->stats.total_requests++;
         auto start = std::chrono::steady_clock::now();
 
-        std::optional<HttpResponse> result;
+        ntq::optional<HttpResponse> result;
         ErrorCode local_err = ErrorCode::None;
 
         const auto full_path = impl_->build_full_path(path);
@@ -411,13 +411,13 @@ namespace ntq
         {
             impl_->stats.total_errors++;
             if (err) *err = local_err;
-            return std::nullopt;
+            return ntq::nullopt;
         }
         if (err) *err = ErrorCode::None;
         return result;
     }
 
-    std::future<std::optional<HttpResponse>> NetRequest::GetAsync(const std::string &path,
+    std::future<ntq::optional<HttpResponse>> NetRequest::GetAsync(const std::string &path,
                                                                   const httplib::Params &query,
                                                                   const httplib::Headers &headers,
                                                                   ErrorCode *err)
@@ -430,7 +430,7 @@ namespace ntq
         });
     }
 
-    std::future<std::optional<HttpResponse>> NetRequest::PostJsonAsync(const std::string &path,
+    std::future<ntq::optional<HttpResponse>> NetRequest::PostJsonAsync(const std::string &path,
                                                                        const std::string &json,
                                                                        const httplib::Headers &headers,
                                                                        ErrorCode *err)
@@ -443,7 +443,7 @@ namespace ntq
         });
     }
 
-    std::future<std::optional<HttpResponse>> NetRequest::PostFormAsync(const std::string &path,
+    std::future<ntq::optional<HttpResponse>> NetRequest::PostFormAsync(const std::string &path,
                                                                        const httplib::Params &form,
                                                                        const httplib::Headers &headers,
                                                                        ErrorCode *err)
@@ -560,4 +560,76 @@ namespace ntq
     {
         return impl_->stats;
     }
+
+    // ------------------------- Quick helpers -------------------------
+    namespace {
+        struct ParsedURL {
+            std::string scheme;
+            std::string host;
+            int port = 0;
+            std::string path_and_query;
+            bool ok = false;
+        };
+
+        static ParsedURL parse_url(const std::string &url)
+        {
+            ParsedURL p; p.ok = false;
+            // very small parser: scheme://host[:port]/path[?query]
+            auto pos_scheme = url.find("://");
+            if (pos_scheme == std::string::npos) return p;
+            p.scheme = url.substr(0, pos_scheme);
+            size_t pos_host = pos_scheme + 3;
+
+            size_t pos_path = url.find('/', pos_host);
+            std::string hostport = pos_path == std::string::npos ? url.substr(pos_host)
+                                                                 : url.substr(pos_host, pos_path - pos_host);
+            auto pos_colon = hostport.find(':');
+            if (pos_colon == std::string::npos) {
+                p.host = hostport;
+                p.port = (p.scheme == "https") ? 443 : 80;
+            } else {
+                p.host = hostport.substr(0, pos_colon);
+                std::string port_str = hostport.substr(pos_colon + 1);
+                p.port = port_str.empty() ? ((p.scheme == "https") ? 443 : 80) : std::atoi(port_str.c_str());
+            }
+            p.path_and_query = (pos_path == std::string::npos) ? "/" : url.substr(pos_path);
+            p.ok = !p.host.empty();
+            return p;
+        }
+    }
+
+    ntq::optional<HttpResponse> NetRequest::QuickGet(const std::string &url,
+                                                     const httplib::Headers &headers,
+                                                     ErrorCode *err)
+    {
+        auto p = parse_url(url);
+        if (!p.ok) { if (err) *err = ErrorCode::InvalidURL; return std::nullopt; }
+        RequestOptions opt; opt.scheme = p.scheme; opt.host = p.host; opt.port = p.port;
+        NetRequest req(opt);
+        return req.Get(p.path_and_query, {}, headers, err);
+    }
+
+    ntq::optional<HttpResponse> NetRequest::QuickPostJson(const std::string &url,
+                                                          const std::string &json,
+                                                          const httplib::Headers &headers,
+                                                          ErrorCode *err)
+    {
+        auto p = parse_url(url);
+        if (!p.ok) { if (err) *err = ErrorCode::InvalidURL; return std::nullopt; }
+        RequestOptions opt; opt.scheme = p.scheme; opt.host = p.host; opt.port = p.port;
+        NetRequest req(opt);
+        return req.PostJson(p.path_and_query, json, headers, err);
+    }
+
+    ntq::optional<HttpResponse> NetRequest::QuickPostForm(const std::string &url,
+                                                          const httplib::Params &form,
+                                                          const httplib::Headers &headers,
+                                                          ErrorCode *err)
+    {
+        auto p = parse_url(url);
+        if (!p.ok) { if (err) *err = ErrorCode::InvalidURL; return std::nullopt; }
+        RequestOptions opt; opt.scheme = p.scheme; opt.host = p.host; opt.port = p.port;
+        NetRequest req(opt);
+        return req.PostForm(p.path_and_query, form, headers, err);
+    }
 }

src/encrypt.cpp

@@ -0,0 +1,91 @@
+#include "encrypt.hpp"
+#include <vector>
+
+namespace encrypt
+{
+    string MD5(const string &info)
+    {
+        auto leftrotate = [](uint32_t x, uint32_t c) -> uint32_t { return (x << c) | (x >> (32 - c)); };
+
+        static const uint32_t s[64] = {
+            7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,  7, 12, 17, 22,
+            5, 9, 14, 20,   5, 9, 14, 20,   5, 9, 14, 20,   5, 9, 14, 20,
+            4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,  4, 11, 16, 23,
+            6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21,  6, 10, 15, 21
+        };
+        static const uint32_t K[64] = {
+            0xd76aa478, 0xe8c7b756, 0x242070db, 0xc1bdceee, 0xf57c0faf, 0x4787c62a, 0xa8304613, 0xfd469501,
+            0x698098d8, 0x8b44f7af, 0xffff5bb1, 0x895cd7be, 0x6b901122, 0xfd987193, 0xa679438e, 0x49b40821,
+            0xf61e2562, 0xc040b340, 0x265e5a51, 0xe9b6c7aa, 0xd62f105d, 0x02441453, 0xd8a1e681, 0xe7d3fbc8,
+            0x21e1cde6, 0xc33707d6, 0xf4d50d87, 0x455a14ed, 0xa9e3e905, 0xfcefa3f8, 0x676f02d9, 0x8d2a4c8a,
+            0xfffa3942, 0x8771f681, 0x6d9d6122, 0xfde5380c, 0xa4beea44, 0x4bdecfa9, 0xf6bb4b60, 0xbebfbc70,
+            0x289b7ec6, 0xeaa127fa, 0xd4ef3085, 0x04881d05, 0xd9d4d039, 0xe6db99e5, 0x1fa27cf8, 0xc4ac5665,
+            0xf4292244, 0x432aff97, 0xab9423a7, 0xfc93a039, 0x655b59c3, 0x8f0ccc92, 0xffeff47d, 0x85845dd1,
+            0x6fa87e4f, 0xfe2ce6e0, 0xa3014314, 0x4e0811a1, 0xf7537e82, 0xbd3af235, 0x2ad7d2bb, 0xeb86d391
+        };
+
+        uint32_t a0 = 0x67452301;
+        uint32_t b0 = 0xefcdab89;
+        uint32_t c0 = 0x98badcfe;
+        uint32_t d0 = 0x10325476;
+
+        std::vector<uint8_t> msg(info.begin(), info.end());
+        uint64_t bit_len = static_cast<uint64_t>(msg.size()) * 8ULL;
+        msg.push_back(0x80);
+        while ((msg.size() % 64) != 56) msg.push_back(0x00);
+        for (int i = 0; i < 8; ++i) msg.push_back(static_cast<uint8_t>((bit_len >> (8 * i)) & 0xff));
+
+        for (size_t offset = 0; offset < msg.size(); offset += 64)
+        {
+            uint32_t M[16];
+            for (int i = 0; i < 16; ++i)
+            {
+                size_t j = offset + i * 4;
+                M[i] = static_cast<uint32_t>(msg[j]) |
+                       (static_cast<uint32_t>(msg[j + 1]) << 8) |
+                       (static_cast<uint32_t>(msg[j + 2]) << 16) |
+                       (static_cast<uint32_t>(msg[j + 3]) << 24);
+            }
+
+            uint32_t A = a0, B = b0, C = c0, D = d0;
+            for (uint32_t i = 0; i < 64; ++i)
+            {
+                uint32_t F, g;
+                if (i < 16) { F = (B & C) | ((~B) & D); g = i; }
+                else if (i < 32) { F = (D & B) | ((~D) & C); g = (5 * i + 1) % 16; }
+                else if (i < 48) { F = B ^ C ^ D; g = (3 * i + 5) % 16; }
+                else { F = C ^ (B | (~D)); g = (7 * i) % 16; }
+
+                F = F + A + K[i] + M[g];
+                A = D;
+                D = C;
+                C = B;
+                B = B + leftrotate(F, s[i]);
+            }
+
+            a0 += A; b0 += B; c0 += C; d0 += D;
+        }
+
+        uint8_t digest[16];
+        auto u32_to_le = [](uint32_t v, uint8_t out[4]) {
+            out[0] = static_cast<uint8_t>(v & 0xff);
+            out[1] = static_cast<uint8_t>((v >> 8) & 0xff);
+            out[2] = static_cast<uint8_t>((v >> 16) & 0xff);
+            out[3] = static_cast<uint8_t>((v >> 24) & 0xff);
+        };
+        u32_to_le(a0, digest + 0);
+        u32_to_le(b0, digest + 4);
+        u32_to_le(c0, digest + 8);
+        u32_to_le(d0, digest + 12);
+
+        static const char *hex = "0123456789abcdef";
+        std::string out;
+        out.resize(32);
+        for (int i = 0; i < 16; ++i)
+        {
+            out[i * 2]     = hex[(digest[i] >> 4) & 0x0f];
+            out[i * 2 + 1] = hex[digest[i] & 0x0f];
+        }
+        return out;
+    }
+}