update:http&&md5

README.md

@@ -108,3 +108,21 @@ auto s = req.getStats();
 说明：
 - 若使用 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/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/Netra.cpp

@@ -494,16 +494,29 @@ namespace QCL
 
     std::vector<std::string> ReadFile::ReadLines()
     {
+        // std::lock_guard<std::mutex> lock(mtx_);
+        // if (!file_.is_open() && !Open())
+        //     return {};
+
+        // std::vector<std::string> lines;
+        // std::string line;
+        // while (std::getline(file_, line))
+        // {
+        //     lines.push_back(line);
+        // }
+        // return lines;
+
         std::lock_guard<std::mutex> lock(mtx_);
-        if (!file_.is_open() && !Open())
-            return {};
+        if (!file_.is_open()) {
+            file_.open(filename_, std::ios::in | std::ios::binary);
+            if (!file_.is_open()) return {};
+        }
+        file_.clear();
+        file_.seekg(0, std::ios::beg);
   
         std::vector<std::string> lines;
         std::string line;
-        while (std::getline(file_, line))
-        {
-            lines.push_back(line);
-        }
+        while (std::getline(file_, line)) lines.push_back(line);
         return lines;
     }
 

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;
+    }
+}