基于C++11与boost库实现boost搜索引擎.zip

cpp-httplib =========== [](https://github.com/yhirose/cpp-httplib/actions) A C++11 single-file header-only cross platform HTTP/HTTPS library. It's extremely easy to setup. Just include **httplib.h** file in your code! NOTE: This is a 'blocking' HTTP library. If you are looking for a 'non-blocking' library, this is not the one that you want. Simple examples --------------- #### Server ```c++ httplib::Server svr; svr.Get("/hi", [](const httplib::Request &, httplib::Response &res) { res.set_content("Hello World!", "text/plain"); }); svr.listen("0.0.0.0", 8080); ``` #### Client ```c++ httplib::Client cli("http://cpp-httplib-server.yhirose.repl.co"); auto res = cli.Get("/hi"); res->status; // 200 res->body; // "Hello World!" ``` ### Try out the examples on Repl.it! 1. Run server at https://repl.it/@yhirose/cpp-httplib-server 2. Run client at https://repl.it/@yhirose/cpp-httplib-client Server ------ ```c++ #include <httplib.h> int main(void) { using namespace httplib; Server svr; svr.Get("/hi", [](const Request& req, Response& res) { res.set_content("Hello World!", "text/plain"); }); svr.Get(R"(/numbers/(\d+))", [&](const Request& req, Response& res) { auto numbers = req.matches[1]; res.set_content(numbers, "text/plain"); }); svr.Get("/body-header-param", [](const Request& req, Response& res) { if (req.has_header("Content-Length")) { auto val = req.get_header_value("Content-Length"); } if (req.has_param("key")) { auto val = req.get_param_value("key"); } res.set_content(req.body, "text/plain"); }); svr.Get("/stop", [&](const Request& req, Response& res) { svr.stop(); }); svr.listen("localhost", 1234); } ``` `Post`, `Put`, `Delete` and `Options` methods are also supported. ### Bind a socket to multiple interfaces and any available port ```cpp int port = svr.bind_to_any_port("0.0.0.0"); svr.listen_after_bind(); ``` ### Static File Server ```cpp // Mount / to ./www directory auto ret = svr.set_mount_point("/", "./www"); if (!ret) { // The specified base directory doesn't exist... } // Mount /public to ./www directory ret = svr.set_mount_point("/public", "./www"); // Mount /public to ./www1 and ./www2 directories ret = svr.set_mount_point("/public", "./www1"); // 1st order to search ret = svr.set_mount_point("/public", "./www2"); // 2nd order to search // Remove mount / ret = svr.remove_mount_point("/"); // Remove mount /public ret = svr.remove_mount_point("/public"); ``` ```cpp // User defined file extension and MIME type mappings svr.set_file_extension_and_mimetype_mapping("cc", "text/x-c"); svr.set_file_extension_and_mimetype_mapping("cpp", "text/x-c"); svr.set_file_extension_and_mimetype_mapping("hh", "text/x-h"); ``` The followings are built-in mappings: | Extension | MIME Type | | :-------- | :--------------------- | | txt | text/plain | | html, htm | text/html | | css | text/css | | jpeg, jpg | image/jpg | | png | image/png | | gif | image/gif | | svg | image/svg+xml | | ico | image/x-icon | | json | application/json | | pdf | application/pdf | | js | application/javascript | | wasm | application/wasm | | xml | application/xml | | xhtml | application/xhtml+xml | NOTE: These the static file server methods are not thread safe. ### Logging ```cpp svr.set_logger([](const auto& req, const auto& res) { your_logger(req, res); }); ``` ### Error handler ```cpp svr.set_error_handler([](const auto& req, auto& res) { auto fmt = "<p>Error Status: <span style='color:red;'>%d</span></p>"; char buf[BUFSIZ]; snprintf(buf, sizeof(buf), fmt, res.status); res.set_content(buf, "text/html"); }); ``` ### 'multipart/form-data' POST data ```cpp svr.Post("/multipart", [&](const auto& req, auto& res) { auto size = req.files.size(); auto ret = req.has_file("name1"); const auto& file = req.get_file_value("name1"); // file.filename; // file.content_type; // file.content; }); ``` ### Receive content with Content receiver ```cpp svr.Post("/content_receiver", [&](const Request &req, Response &res, const ContentReader &content_reader) { if (req.is_multipart_form_data()) { MultipartFormDataItems files; content_reader( [&](const MultipartFormData &file) { files.push_back(file); return true; }, [&](const char *data, size_t data_length) { files.back().content.append(data, data_length); return true; }); } else { std::string body; content_reader([&](const char *data, size_t data_length) { body.append(data, data_length); return true; }); res.set_content(body, "text/plain"); } }); ``` ### Send content with Content provider ```cpp const size_t DATA_CHUNK_SIZE = 4; svr.Get("/stream", [&](const Request &req, Response &res) { auto data = new std::string("abcdefg"); res.set_content_provider( data->size(), // Content length "text/plain", // Content type [data](size_t offset, size_t length, DataSink &sink) { const auto &d = *data; sink.write(&d[offset], std::min(length, DATA_CHUNK_SIZE)); return true; // return 'false' if you want to cancel the process. }, [data] { delete data; }); }); ``` Without content length: ```cpp svr.Get("/stream", [&](const Request &req, Response &res) { res.set_content_provider( "text/plain", // Content type [&](size_t offset, size_t length, DataSink &sink) { if (/* there is still data */) { std::vector<char> data; // prepare data... sink.write(data.data(), data.size()); } else { sink.done(); // No more data } return true; // return 'false' if you want to cancel the process. }); }); ``` ### Chunked transfer encoding ```cpp svr.Get("/chunked", [&](const Request& req, Response& res) { res.set_chunked_content_provider( [](size_t offset, DataSink &sink) { sink.write("123", 3); sink.write("345", 3); sink.write("789", 3); sink.done(); // No more data return true; // return 'false' if you want to cancel the process. } ); }); ``` ### 'Expect: 100-continue' handler As default, the server sends `100 Continue` response for `Expect: 100-continue` header. ```cpp // Send a '417 Expectation Failed' response. svr.set_expect_100_continue_handler([](const Request &req, Response &res) { return 417; }); ``` ```cpp // Send a final status without reading the message body. svr.set_expect_100_continue_handler([](const Request &req, Response &res) { return res.status = 401; }); ``` ### Keep-Alive connection ```cpp svr.set_keep_alive_max_count(2); // Default is 5 ``` ### Timeout ```c++ svr.set_read_timeout(5, 0); // 5 seconds svr.set_write_timeout(5, 0); // 5 seconds svr.set_idle_interval(0, 100000); // 100 milliseconds ``` ### Set maximum payload length for reading request body ```c++ svr.set_payload_max_length(1024 * 1024 * 512); // 512MB ``` ### Server-Sent Events Please see [Server example](https://github.com/yhirose/cpp-httplib/blob/master/example/ssesvr.cc) and [Client example](https://github.com/yhirose/cpp-httplib/blob/master/example/ssecli.cc). ### Default thread pool support `ThreadPool` is used as a **default** task queue, and the default thread count is 8, or `std::thread::hardware_concurrency()`. You can change it with `CPPHTTPLIB_THREAD_POOL_COUNT`. If you want to set the thread count at runtime, there is no convenient way... But here is how. ```cpp svr.new_task_queue = [] { return new ThreadPool(12); }; ``` ### Override the default thread pool with yours You can supply your own thread pool implementation according to your need. ```cpp class YourThreadPoolTask