Add Docs PWA placeholder, so we can list it on cloudflare as a PWA (#1238)

* unfinshed overhual of c's fwrite/fread etc

* done

* self-reference for pyobject_file

* No exemption of ANY devices for this library for anti-tivo

It is scary to think self-driving cars could be planted with backdoors
to kill anyone. That is INSANE

* [Qt] qiodevice uses new mechanism

* qiodevice

* initial_attempt for strbset

* initial attempt for str_btreeset.h

* btree

* btreeset

* [btree_set] testing

* [str_btree_set] move the example to test

* set

* [btree] root needs to change in the case when node->parent == nullptr

* str

* [btree] set nullptr for root?

* str_btree_set

* str_btree_set2.h

* put debugging information in it first

* [str_btree_set] implement more logic for btree

* [btreeset] more logic for fix up

* [BTree] Fix & missing in str_btree_set.h

* btree

* [str_btree_set] Fix str_btree_set.h

* [str_btree_set] Some changes to fuzz the code

* [btree] Fix btree

* [btree] add fuzzing to debug the code

* rd

* fix bug in str_bree_set

* fix branch in str_btree_set.h

* fix str_btree_set

* update test

* clang-format for str_btree_set_reverse.cc

* str_btree_set

* add a test for str_btree_set_input

* [btree] fix one more bug here

* [str_btree_set] add fast_io_dsal/str_btree_set.h

* [str_btree_set] fix str_btree_set.h

* [str_btree_set] add a benchmark for str_btree_set

* [str_btree_set] add contains

* [str_btree_set] add ::std::unordered_set bench

* [str_btree_set] fix up str btree set

* [str_tree_set] btree should only allow even numbers of key

* [str_btree_set] add some benchmarks

* [str_btree_set] fix main.rs in rustbtree bench

* [str_btree_set] fix main.rs

* [str_btree_set] rust is a bs lang
wtf design a random number generate without std + low...=high or low...
high_exclusive

* [str_btree_set] use two string types

* disable benchmark for str_btree_set

* [str_btree_set] Fix the test CI

* [str_tree_set] add iterator implementation for str_btree_set

* [str_btree_set] str_btree_set add leftmost and rightmost

* [str_tree_set] implement str_btree iterator

* [str_btree_set] add benchmarks for iteration

* [str_btree_set] remove nullptr check for -- iterator

* [str_btree_set] fix operator-- for iterator

* [str_btree_set] add iteration bench for abseil

* [btree] add the bench to rust code

* [btree] add iteration bench for abseil_btree_set_fast_io

* [str_btree_set] add find method

* [str_btree_set] implement find()

* [str_btree_set] put a placeholder for erase

* [str_btree_set] fix around str_btree_set

* [str_btree_set] merge code

* Add sock_protocol QUIC

* add some content to str_btree_set

* btree

* add a simple wifianalyzer

* add scanning logic

* add logic to print out even after scanning timeout

* wifi quality

* win32

* add covers

* remove ln

* pin12

* Fix warnings for char32_t casting

* correctly ignore wifianalyzer example

* remove unused variable

* Use reverse_iterator instead of reverse_view since CI does not support it

* Fix str_btree_set.cc

* fix ifdef issue for printf

* using a universal type convert for fixing the is_dos_file_invalid_character merging issue

* Change the example's min len for password ans specialpassword to 12 to match the PWA GenPass version.

* implement full str_btree_set's erase

* add str_btree_erase fuzzer

* add the erase that covers entire function

* use chatgpt to rewrite the code

* clang-format to str_btree_set.h

* extract fix_child_links in str_btree_set

* call function needs to use full name

* Add docs

---------

Co-authored-by: ombhntlar <tfnhtar@ombhntlars-Mac-mini.lan>

Author: trcrsired

benchmark/0011.containers/.test_prop.toml

@@ -0,0 +1,3 @@
+["str_btree_set"]
+ignore = true
+

benchmark/0011.containers/str_btree_set/abseil_btree_set.cc

@@ -0,0 +1,54 @@
+#include <unordered_set>
+#include <string>
+#include <absl/container/btree_set.h>
+#include <fast_io.h>
+#include <fast_io_dsal/string.h>
+#include <fast_io_driver/timer.h>
+#include "gentest.h"
+
+int main()
+{
+	auto vec{::gentest<::std::string>()};
+	::fast_io::timer t(u8"str_btree_set");
+	::absl::btree_set<typename decltype(vec)::value_type> bset;
+	{
+		::fast_io::timer t(u8"insert");
+		for (auto const &e : vec)
+		{
+			bset.insert(e);
+		}
+	}
+	{
+		::std::size_t count{};
+		{
+			::fast_io::timer t(u8"contains");
+			for (auto const &e : vec)
+			{
+				count += static_cast<::std::size_t>(bset.contains(e));
+			}
+		}
+		::fast_io::io::perrln("count=", count);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"iteration");
+			for (auto const &e : bset)
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"reverse iteration");
+			for (auto const &e : ::std::ranges::reverse_view(bset))
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+}

benchmark/0011.containers/str_btree_set/abseil_btree_set_fast_io.cc

@@ -0,0 +1,54 @@
+#include <unordered_set>
+#include <string>
+#include <absl/container/btree_set.h>
+#include <fast_io.h>
+#include <fast_io_dsal/string.h>
+#include <fast_io_driver/timer.h>
+#include "gentest.h"
+
+int main()
+{
+	auto vec{::gentest()};
+	::fast_io::timer t(u8"str_btree_set");
+	::absl::btree_set<::fast_io::string> bset;
+	{
+		::fast_io::timer t(u8"insert");
+		for (auto const &e : vec)
+		{
+			bset.insert(e);
+		}
+	}
+	{
+		::std::size_t count{};
+		{
+			::fast_io::timer t(u8"contains");
+			for (auto const &e : vec)
+			{
+				count += static_cast<::std::size_t>(bset.contains(e));
+			}
+		}
+		::fast_io::io::perrln("count=", count);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"iteration");
+			for (auto const &e : bset)
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"reverse iteration");
+			for (auto const &e : ::std::ranges::reverse_view(bset))
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+}

benchmark/0011.containers/str_btree_set/gentest.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <fast_io_dsal/vector.h>
+#include <fast_io_dsal/string.h>
+#include <random>
+
+template <typename T = ::fast_io::string>
+inline ::fast_io::vector<T> gentest()
+{
+	::fast_io::vector<T> vec;
+	::std::mt19937_64 eng;
+	::std::uniform_int_distribution<std::size_t> ud(0, 61);
+	::std::uniform_int_distribution<std::size_t> rlen(25, 30);
+	for (::std::size_t i{}; i != 1000000; ++i)
+	{
+		T tempstr;
+		::std::size_t n{rlen(eng)};
+		tempstr.reserve(n);
+		for (::std::size_t j{}; j != n; ++j)
+		{
+			char8_t ch(static_cast<char8_t>(ud(eng)));
+			if (ch < 10u)
+			{
+				ch += u8'0';
+			}
+			else if (ch < 36u)
+			{
+				ch = ch - 10u + u8'a';
+			}
+			else
+			{
+				ch = ch - 36u + u8'A';
+			}
+			tempstr.push_back(ch);
+		}
+		vec.emplace_back(::std::move(tempstr));
+	}
+	return vec;
+}

benchmark/0011.containers/str_btree_set/rustbtree/Cargo.toml

@@ -0,0 +1,7 @@
+[package]
+name = "rustbtree"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+rand = "0.9.1"

benchmark/0011.containers/str_btree_set/rustbtree/src/main.rs

@@ -0,0 +1,77 @@
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
+use std::collections::BTreeSet;
+use std::time::Instant;
+
+fn generate_test_data() -> Vec<String> {
+    let mut vec = Vec::with_capacity(1_000_000);
+    let mut rng = StdRng::seed_from_u64(0xDEADBEEF); // deterministic seed
+
+    for _ in 0..1_000_000 {
+        let len = rng.random_range(25..=30); // replaces Uniform(8, 20)
+        let mut s = String::with_capacity(len);
+
+        for _ in 0..len {
+            let x = rng.random_range(0..=61); // replaces Uniform(0, 61)
+            let ch = match x {
+                x if x < 10 => (b'0' + x as u8) as char,
+                x if x < 36 => (b'a' + (x - 10) as u8) as char,
+                _ => (b'A' + (x - 36) as u8) as char,
+            };
+            s.push(ch);
+        }
+
+        vec.push(s);
+    }
+
+    vec
+}
+
+fn main() {
+    let vec = generate_test_data();
+    let start_total = Instant::now();
+    println!("str_btree_set test started");
+
+    let mut bset = BTreeSet::new();
+
+    let start_insert = Instant::now();
+    for s in &vec {
+        bset.insert(s.clone()); // cloning to move into BTreeSet
+    }
+    println!("insert_key: {:.2?}", start_insert.elapsed());
+
+    let mut count = 0;
+    let start_contains = Instant::now();
+    for s in &vec {
+        if bset.contains(s) {
+            count += 1;
+        }
+    }
+    println!("contains: {:.2?}", start_contains.elapsed());
+    // 🚀 Forward iteration benchmark
+    let mut total_size = 0;
+    let start_iter = Instant::now();
+    for s in &bset {
+        total_size += s.len();
+    }
+    println!(
+        "forward iteration total_size = {}, elapsed: {:.2?}",
+        total_size,
+        start_iter.elapsed()
+    );
+
+    // 🔄 Reverse iteration benchmark
+    let mut total_size = 0;
+    let start_rev_iter = Instant::now();
+    for s in bset.iter().rev() {
+        total_size += s.len();
+    }
+    println!(
+        "reverse iteration total_size = {}, elapsed: {:.2?}",
+        total_size,
+        start_rev_iter.elapsed()
+    );
+
+    println!("count = {}", count);
+    println!("total time: {:.2?}", start_total.elapsed());
+}

benchmark/0011.containers/str_btree_set/std_set.cc

@@ -0,0 +1,52 @@
+#include <set>
+#include <string>
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include "gentest.h"
+
+int main()
+{
+	auto vec{::gentest<::std::string>()};
+	::fast_io::timer t(u8"str_btree_set");
+	::std::set<typename decltype(vec)::value_type> bset;
+	{
+		::fast_io::timer t(u8"insert");
+		for (auto const &e : vec)
+		{
+			bset.insert(e);
+		}
+	}
+	{
+		::std::size_t count{};
+		{
+			::fast_io::timer t(u8"contains");
+			for (auto const &e : vec)
+			{
+				count += static_cast<::std::size_t>(bset.contains(e));
+			}
+		}
+		::fast_io::io::perrln("count=", count);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"iteration");
+			for (auto const &e : bset)
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"reverse iteration");
+			for (auto const &e : ::std::ranges::reverse_view(bset))
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+}

benchmark/0011.containers/str_btree_set/std_set_fast_io.cc

@@ -0,0 +1,52 @@
+#include <set>
+#include <string>
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include "gentest.h"
+
+int main()
+{
+	auto vec{::gentest()};
+	::fast_io::timer t(u8"str_btree_set");
+	::std::set<::fast_io::string> bset;
+	{
+		::fast_io::timer t(u8"insert");
+		for (auto const &e : vec)
+		{
+			bset.insert(e);
+		}
+	}
+	{
+		::std::size_t count{};
+		{
+			::fast_io::timer t(u8"contains");
+			for (auto const &e : vec)
+			{
+				count += static_cast<::std::size_t>(bset.contains(e));
+			}
+		}
+		::fast_io::io::perrln("count=", count);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"iteration");
+			for (auto const &e : bset)
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+	{
+		::std::size_t total_size{};
+		{
+			::fast_io::timer t(u8"reverse iteration");
+			for (auto const &e : ::std::ranges::reverse_view(bset))
+			{
+				total_size += e.size();
+			}
+		}
+		::fast_io::io::perrln("total_size=", total_size);
+	}
+}

benchmark/0011.containers/str_btree_set/std_unordered_set.cc

@@ -0,0 +1,30 @@
+#include <unordered_set>
+#include <string>
+#include <fast_io.h>
+#include <fast_io_driver/timer.h>
+#include "gentest.h"
+
+int main()
+{
+	auto vec{::gentest<std::string>()};
+	::fast_io::timer t(u8"str_btree_set");
+	::std::unordered_set<::std::string> bset;
+	{
+		::fast_io::timer t(u8"insert");
+		for (auto const &e : vec)
+		{
+			bset.insert(e);
+		}
+	}
+	{
+		::std::size_t count{};
+		{
+			::fast_io::timer t(u8"contains");
+			for (auto const &e : vec)
+			{
+				count += static_cast<::std::size_t>(bset.contains(e));
+			}
+		}
+		::fast_io::io::perrln("count=", count);
+	}
+}