🚀 JH-Toolkit v1.3.4 — Structured Bindings, Bitflags Fixes, and LTS Transition

We are proud to release JH-Toolkit v1.3.4,
the first LTS-driven release of the 1.3.x series —
marking full structured-binding support across all POD types and corrected native bitflag semantics.
This version finalizes the POD modernization milestone and establishes the new LTS release workflow moving forward.

---

🔹 Highlights

🧩 Structured Binding for POD Types

The jh::pod module now provides complete, STL-aligned structured binding semantics.

• New: jh::pod::tuple — a POD-compatible structured tuple
  with full interoperability with std::tuple_size / std::tuple_element.

• Extended: structured binding support for:

  • jh::pod::pair
  • jh::pod::array

• New helper: jh::pod::make_pair() — STL-aligned convenience for POD pairs.

🧠 These updates make POD data types natively compatible with modern C++23 binding syntax,
allowing seamless interaction with structured assignment and generic tuple utilities.

---

⚙️ Bitflags Type Correction

Native-width jh::pod::bitflags (8/16/32/64-bit) now correctly preserve
their derived type in bitwise operations, instead of decaying to the base implementation type.

• Ensures consistent type deduction in all operator overloads.
• Improves constexpr behavior and API predictability.
• Fully backward-compatible with prior bitflag definitions.

---

📘 Documentation and Metadata Standardization

• All internal includes standardized to absolute paths (jh/pods/...).
• Doxygen headers unified and expanded across modified modules.
• All .md references updated and versioned to 1.3.4+.
• jh::ranges documentation completed for code freeze:
  • Introduced jh::ranges_ext (1.3.5 preview): pre-standard "semantic extension" layer
    offering to-like behaviors with duck-type compatibility.
• Clarified POD layout conventions (std::size_t vs uint*_t).

---

🧪 CI and Cross-Platform Validation

• Full matrix executed on publish:

  • 🐧 Linux (Ubuntu / GCC 13+)
  • 🍎 macOS (LLVM 20)
  • 🪟 Windows (MSYS2 UCRT64 / MinGW-w64)

• Automatic metadata refresh through Update Dependencies workflow:

  • dependencies.json
  • version_badge.json
  • documentation version stamps

• All regression and new feature tests passed.

---

🔸 Compatibility Summary

Aspect	Status	Note
API	⚙️ Extended but backward-compatible	Added tuple, make_pair, and structured binding for pair / array.
ABI	⚙️ Modified, compatible re-layout	POD layout refined for native-sized bitflags and structured bindings.
Behavior	✅ Stable	No breaking changes; improved semantics and operator correctness.
Tests	✅ Pass	All regression and feature suites validated across platforms.

---

🔹 Workflow Transition — LTS as the Primary Release Source

Beginning with v1.3.4,
the 1.3.x series transitions to an LTS-based release model:

• All future 1.3.x updates (e.g., 1.3.5, 1.3.6, …)
  will originate from the 1.3.x-LTS branch, not main.

• This ensures direct alignment with active maintenance and future synchronization paths:

  • 1.3.x-LTS → 1.4.0-dev
  • 1.4.0-dev → 1.4.x-LTS

• The main branch now serves as a historical reference only for the 1.3.3 milestone and earlier.

• All merges, fixes, and documentation updates will flow from LTS branches forward,
  guaranteeing consistent, conflict-free integration across all active versions.

🧭 From this point onward, 1.3.x-LTS becomes the authoritative release branch for the 1.3 line.

---

🚀 Next Steps

1. Start 1.3.5-dev development (focused on jh::ranges_ext and jh::views C++23 alignment).
2. Forward-sync 1.3.x-LTS → 1.4.0-dev for unified evolution.
3. Continue documentation consolidation toward 1.4.x-LTS.

---

🤝 Contributing

We welcome contributions aligned with STL conventions and modern C++20 practices.
Refer to the updated CONTRIBUTING.md
for branching, review, and release procedures.

🔒 Protected branches (main, *-LTS) accept changes only through <version>-dev merges,
ensuring consistent version traceability and reproducible builds.

---

🧠 JH Toolkit continues its mission as a modular, RTTI-free foundation for
type-safe, behaviorally consistent, and modern C++20 —
bridging clarity, performance, and standard evolution across platforms.

---

Tag: JH-Toolkit-1.3.4
Series: 1.3.x-LTS (LTS-driven release model established)

🚀 JH-Toolkit v1.3.3 — Dual-Mode Architecture, Structural Refinement, and Full Documentation Update

We are proud to release JH-Toolkit v1.3.3, the latest milestone in the 1.3.x LTS series.
This version establishes a unified dual-mode build system, introduces broad structural refinements across modules,
and delivers a complete rewrite of documentation — defining the finalized foundation for the upcoming 1.4.x evolution.

---

🔹 Dual-Mode Architecture — Unified Header and Static System

JH Toolkit now fully supports both header-only and static build modes under a unified architecture.
Both configurations share a single codebase and provide identical API and ABI behavior.

• Link targets:

  • jh::jh-toolkit — header-only build
  • jh::jh-toolkit-static — static library build

• The legacy entry jh::jh-toolkit-impl remains as an alias to jh::jh-toolkit-static for compatibility.

• Powered by the new dual-mode header system, which eliminates duplicated maintenance between header and static sources.

🧩 For users, the system is completely transparent — no extra macros, flags, or options are required.
Simply link against the desired target.
When using install with default settings (equivalent to -DTAR=ALL), both targets are automatically built and exported.

---

🔹 Structural and Module Refinement

The entire internal structure of JH Toolkit has been reorganized for greater maintainability, clarity, and forward compatibility.

• Module directories have been restructured with cleaner hierarchy and separation of concerns.
• The reorganization prepares the codebase for the 1.4.x concurrency and process-control extensions.
• All public 1.3.x interfaces remain fully valid and backward-compatible.
• Deprecated forwarding headers are retained for smooth migration.

✅ The 1.3.x LTS line remains ABI- and API-stable — all existing integrations continue to build and link unchanged.

---

🔹 Views and Ranges System — C++23 Alignment

The jh::views subsystem has been fully rewritten and now conforms to C++23 std::ranges::zip_view semantics.

• jh::views::zip and jh::views::enumerate are rebuilt atop jh::ranges::zip_view, ensuring precise parity with C++23 behavior.
• jh::concepts and jh::to_range improved to bridge duck-typed and standard containers seamlessly.
• Documentation now focuses on behavioral usability — what developers can do, not just implementation details.

---

🔹 Behavioral and Internal Refinements

• jh::concepts::iterator submodule has been fully decoupled from std::iterator_traits,
  defining its own concept-based introspection layer for true duck-typed iteration.
• jh::to_range(seq) has been refactored with a new proxy mechanism — more predictable lifetime and semantics.
• jh::sim_pool now defines deterministic move behavior, ensuring predictable reuse and reference consistency.
• jh::pod::stringify submodule is now entirely RTTI-free, completing the library’s transition to a fully -fno-rtti compatible codebase.

🧩 These refinements mark the first complete RTTI-free release of the toolkit.

---

🔹 Documentation and Contributor Updates

• CONTRIBUTING.md has been fully updated to reflect the current development standards:

  • Explicit RTTI-free guarantee (compatible with -fno-rtti)
  • Strict merge-only policy for main and all *-LTS branches
  • Defined workflow for active, maintenance, and EOL series
  • Clarified that CMake is the single authoritative version source

• API documentation rewritten from a capability-oriented perspective — emphasizing user intent and expressiveness.

• README.md updated:

  • Replaced Shields.io CI badge with the native GitHub Actions badge for cleaner presentation
  • Improved layout, typography, and readability

---

🤝 Contributing

We continue to welcome explicit, STL-aligned, and modern contributions.
Refer to the updated CONTRIBUTING.md for detailed development and release procedures.

🔒 All protected branches (main, *-LTS) accept changes only via <version>-dev merges to ensure traceable version integrity.

---

🧠 JH Toolkit remains a modular, RTTI-free foundation for behaviorally compatible, type-safe, and concurrency-stable C++20 —
bridging clarity, performance, and modern design across all supported platforms.

---

Tag: JH-Toolkit-1.3.3
Series: 1.3.x-LTS (final feature-aligned release before 1.4.x transition)

🚀 JH-Toolkit v1.3.2 — POD Type Aliases, Pool Stability, CI Fixes

We’re proud to release JH-Toolkit v1.3.2, the next step in the 1.3.x LTS series.
This update focuses on POD container refinements, stable pooling under churn, and CI/compiler reliability — while preserving ABI and API stability.

---

🔹 POD System Enhancements

• STL-style POD containers (pod::span, pod::array, pod::pair) now provide std-compatible type aliases:
  element_type, size_type, etc. → generic code written for std::span or std::pair works seamlessly.
  pod::string_view also exposes a pseudo-value_type = char for interop with std::string_view.
• pod::optional<T>: clarified ABI (sizeof == sizeof(T) + 1), added .value_or() and nullopt printing.
• pod::string_view: enriched docs; clarified content-based equality vs span’s address-based equality.
• stringify utilities: operator<< for all core POD wrappers (array, pair, optional, bitflags, bytes_view, span, string_view).
  → Human-readable debugging distinct from stable serialization (bytes_view + base64).
• 📖 Full POD API documentation updated → see docs/pod.md.

---

🔹 Pool & String Improvements

• sim_pool: refined allocation policy to avoid repeated thrashing near capacity limits, ensuring smoother behavior under high churn.
• immutable_str: now uses transparent template deduction for more stable interop with std::string_view, reducing implicit copies in generic code.
• ✅ Public API unchanged — all 1.3.x clients remain source- and ABI-compatible.

---

🔹 CI & Compiler Fixes

• CI now explicitly enforces LLVM Clang 20 + libc++, avoiding unstable std::hash exports seen in intermediate Clang builds.

• Local (Clang ≥20.1.3) and legacy CI (Clang 15) were stable → issue traced to mid-upgrade CI environment.

• 🛠 CMake Release builds no longer blindly use -march=native. Instead:

  • On native builds → -march=native
  • On cross-compiling builds → choose SIMD-safe fallback (-march=x86-64-v3, -march=armv8-a)
  • ℹ️ armv7 is provided only as fallback; 32-bit remains unsupported.
  • ✅ Supports homogeneous cross-compilation (x86↔x86, arm↔arm) reliably.
  • ⚠️ Heterogeneous cross-compilation is discouraged: possible performance regressions and ABI overhead.

---

🔹 Documentation Updates

• Updated headers for sim_pool and immutable_str:
  @version 1.2.x → 1.3.x.
• docs/pod.md expanded to cover stringify vs serialization.
• README.md updated to v1.3.2 highlights.

---

🤝 Contributing

We continue to welcome clean, STL-aligned code contributions!
See CONTRIBUTING.md.

---

🧠 JH Toolkit remains a modern, modular foundation for expressive C++20.
🚀 Thanks for helping build a stable, high-performance toolkit!

🚀 JH-Toolkit v1.3.1 — Conan Packaging Support + POD Hashing Update

We’re excited to release JH-Toolkit v1.3.1, a feature-focused update in the 1.3.x LTS series, introducing CI-packaged Conan .tar.gz archives, and a major enhancement to the POD system’s hashing capabilities — all while maintaining ABI stability and modern C++20 compatibility.

---

🧩 POD Hashing Now Flexible

• pod::string_view and pod::bytes_view now support selectable hash algorithms:

  using enum jh::utils::c_hash;
  sv.hash(fnv1a64); sv.hash(djb2); sv.hash(sdbm);

• Fully backward-compatible: default algorithm remains fnv1a64.

🔍 Enables content-addressable containers, hash-based lookup tuning, and easier debugging of serialized views.

---

📦 Conan Packaging via GitHub Releases

All Conan packages are now built in CI and distributed as .tar.gz archives under GitHub Release assets.

This format avoids reliance on Conan 1.x or GitHub Packages, and ensures quick CI-ready deployment with consistent cache paths.

🔹 Available Archives (v1.3.1)

Package	Type	Platform	Notes
jh-toolkit-pod	Header-only POD	All	Platform-agnostic, compiler-independent
jh-toolkit	Full build	Linux x86_64	Built with GCC 12 in CI
jh-toolkit	Full build	macOS ARM64	Built with Homebrew Clang 16

❌ Windows builds are excluded: Conan 2.x on MSYS2 UCRT64 incorrectly injects MSVC
🚫 Linux ARM64 builds are skipped: GitHub-hosted runners lack reliable QEMU + Docker support

---

⚙️ Using Precompiled Packages

wget https://github.com/JeongHan-Bae/JH-Toolkit/releases/download/JH-Toolkit-1.3.1/jh-toolkit-linux-x86_64-1.3.1.tar.gz
mkdir -p ~/.conan2/p/jh-toolkit
tar -xzf jh-toolkit-linux-x86_64-1.3.1.tar.gz -C ~/.conan2/p/jh-toolkit

💡 For best results, use these only on systems that match CI architecture (e.g. for automation or quick restore).
🔧 Otherwise, build locally from source for full compiler integration.

---

🧱 Installation Modes Recap

Build Target	CMake Option	CMake Targets Available
POD only	-DTAR=POD	jh::jh-toolkit-pod
Full build	-DTAR=ALL	jh::jh-toolkit, jh::jh-toolkit-impl
Combined	-DTAR=POD,ALL	All targets above

✅ Use POD when minimal dependency, fast compile, and ABI control are desired
✅ Use ALL or POD,ALL for full support including coroutine, views, and pooling

---

🛠 Minor Improvements

• CI now includes Conan profile detection and consistent layout generation
• Release assets contain properly versioned Conan caches
• Versioning is synchronized across all entry points:
  • README.md
  • CMakeLists.txt
  • .github/workflows/release.yml

---

🤝 Contributing

We welcome clean, STL-aligned code contributions! See CONTRIBUTING.md for rules and practices.

---

🧠 jh-toolkit-pod is not a C-style embedded component — it’s a lightweight, fully modern C++20 foundation for all performance-focused systems.
🚀 Thank you for using and supporting expressive, modular, and efficient C++ with JH-Toolkit.

🚀 JH-Toolkit v1.3.0 - First Stable Release of 1.3.x LTS

We’re excited to announce the release of JH-Toolkit v1.3.0, the first Long-Term Support (LTS) version in the 1.3.x series!
This release introduces modern runtime structures, STL-compatible pipelines, coroutine-powered generators, and enhanced packaging options — all while preserving JH-Toolkit’s philosophy of zero-cost abstraction and expressive C++20 design.

---

🔥 What's New in JH-Toolkit 1.3.0?

✨ Runtime-Aware Structures

• runtime_arr<T>
  A heap-allocated, fixed-size array with raw layout and STL-like syntax.
  Optimized for PODs and primitive types, it avoids unnecessary heap behavior and is faster than std::vector<T>(N) in fully-initialized cases.

🔁 Ranges and Views Interop

• sequence + jh::to_range(seq)
sequence concept now enables std::ranges::input_range-compatible views for smooth STL integration.
• New module: jh::views
  Introduces lightweight, allocation-free adaptors (enumerate, zip) for sequence instead of ranges, with no RTTI overhead.

🌀 Coroutine Generators

• generator<T> now supports lazy range construction
  You can now create lazy, single-pass STL-compatible ranges via jh::to_range(fn) using co_yield-based logic.

  Only available for non-send (i.e. U = monostate) generators.

🔒 Immutable Strings

• Transparent key lookup support
  shared_ptr<immutable_str> can now be used in hash containers without explicit construction:

  if (pool.find("cached") != pool.end()) { /* ... */ }

• ABI-stable layout, thread-safe access, and enhanced hash interoperability.

---

📦 New: POD-Only Package

A standalone archive jh-toolkit-pod-1.3.0.tar.gz is now available for header-only deployment of the pod module:

• Extracts to: jh-toolkit-pod/
• Easily embedded in external projects:

  target_include_directories(your_project PRIVATE external/jh-toolkit-pod/include)

Ideal for lightweight deployment, internal use, or projects that only need value-type utilities.

---

🛠 Modular Installation Modes

You can now selectively install toolkit components:

Build Target	CMake TAR Value	CMake Targets
POD only	POD	jh::jh-toolkit-pod
Full build	ALL	jh::jh-toolkit, jh::jh-toolkit-impl
Both	POD,ALL	All targets above

Enables precise dependency control for embedded or performance-critical use cases.

---

🧪 Performance & Usability Enhancements

• Lightweight benchmarks added for immutable_str and runtime_arr
• FastDebug mode (-O2 -g) enables faster CI without sacrificing reproducibility
• Full support for unit testing via ctest with capped randomized iterations

---

🧱 Pythonic, STL-Compatible Design

JH-Toolkit continues to follow Python-inspired design principles:

• 🧠 Duck typing and compile-time validation via concepts
• 🔁 Lazy evaluation using coroutines and views
• 🔒 Smart memory via RAII + pooling
• 📚 Readable and expressive template interfaces
• 🐍 Native snake_case naming for seamless integration with std

---

🧰 Toolchain Compatibility

Platform	Compiler	Notes
Linux	GCC 12+	CI-tested with Ubuntu + GCC 12
macOS	Apple Clang 16+ / LLVM Clang 16+	Use Homebrew LLVM if Xcode is outdated
Windows	MSYS2 UCRT64 (GCC 13+)	MSVC is explicitly unsupported

❌ MSVC is blocked at compile-time due to missing C++20 coroutine/range features.
✅ Recommended: WSL2 + GCC, or MSYS2 (UCRT64)

---

📥 Installation

Option 1: Clone the Latest LTS or Download Source Code from this Release

git clone --branch 1.3.x-LTS --depth=1 https://github.com/JeongHan-Bae/jh-toolkit.git

Option 2: Use Prepackaged POD Module

Download jh-toolkit-pod-1.3.0.tar.gz and extract to your project.

---

🔧 Build and Install

Full Build

cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build
sudo cmake --install build

Header-Only POD Build

cmake -B build-pod -DCMAKE_BUILD_TYPE=Release -DTAR=POD
cmake --build build-pod
sudo cmake --install build-pod

---

🧩 CMake Integration

find_package(jh-toolkit REQUIRED)

add_executable(my_project main.cpp)
target_link_libraries(my_project PRIVATE jh::jh-toolkit)
target_link_libraries(my_project PRIVATE jh::jh-toolkit-impl) # compiled components

---

✅ Test Installation of Entire Project

#include <jh/immutable_str>
int main() {
    auto pool = jh::pool<jh::immutable_str>();
    auto str = pool.acquire("Hello, JH Toolkit!");
    std::cout << str->view() << '\n';
}

---

📚 Core Modules

Module	Description
pod	Lightweight POD types (array, bitflags, optional)
runtime_arr	Fixed-size runtime arrays with raw layout
generator	Coroutine-based stream generators
views	Lazy adaptors: zip, enumerate, etc.
pool	Shared/weak pointer-based object pooling
immutable_str	ABI-stable, thread-safe immutable strings

---

🌟 Looking Ahead in 1.3.x

• Continued STL integration improvements
• Coroutine micro-optimizations
• More views and pipeline utilities
• Type-safe factory tools for meta-programming

---

🤝 Contributing

Your feedback and contributions are welcome!

• 📂 GitHub: JH-Toolkit
• 📝 Documentation: README

---

🚀 Thank you for using JH-Toolkit — built for expressive, modern, high-performance C++20 development. 🚀

🚀 JH-Toolkit v1.2.3 - First Stable Release of 1.2.x LTS

We are excited to announce the release of JH-Toolkit v1.2.3, marking the first stable version in the 1.2.x Long-Term Support (LTS) series! This release introduces key improvements in cross-platform support, build configuration refinements, and new usability features.

---

🔥 What's New in JH-Toolkit 1.2.3?

✅ CMake Compatibility Enhancements

• CMake build requirement lowered to 3.20+, ensuring broader compatibility with older Linux distributions.
• CMake usage requirement remains at 3.14+, allowing seamless integration into existing projects.

🆕 New Feature: Unified Header Inclusion

• Headers can now be included using both styles:

  #include <jh/header>
  #include <jh/header.h>

  This ensures a more flexible and user-friendly experience, accommodating different coding preferences.

🔄 Performance & Usability Improvements

• Enhanced jh::immutable_str constructor:
  • Now supports construction from any type implicitly convertible to std::string_view.
  • Introduces safe_from(std::string_view, std::mutex&) for safe shared construction when dealing with mutable sources.
• jh::pool<T> Enhancements:
  • Weak pointer-based content-aware pooling now integrates seamlessly with jh::immutable_str.
  • Automatic cleanup of expired objects—no need for manual tracking.
  • Custom hash & equality support for optimized storage of unique instances.

🛠 Cross-Platform Support Enhancements

• Fully tested and optimized for Linux & macOS with GCC and Clang.
• Windows MinGW support improved, but MSVC remains unsupported due to C++20 limitations.
• Recommended for Windows ARM64: Use GCC within WSL2 for the best experience.

---

📌 Requirements

• C++20 (mandatory)
• CMake 3.14+ (for library usage)
• CMake 3.20+ (for building & installation)
• GCC 10+ / Clang 10+ (tested & supported)
• Git (required for debugging mode compilation)

Ensure your project enables C++20 to avoid compilation issues:

set(CMAKE_CXX_STANDARD 20)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

---

📥 Installation & Usage

🔹 Get the Latest LTS Release (1.2.3)

git clone --branch 1.2.x-LTS --depth=1 https://github.com/JeongHan-Bae/jh-toolkit.git

👉 Or download from: JH Toolkit Latest LTS Release

🔧 Build and Install

cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build
sudo cmake --install build

🛠 CMake Integration

find_package(jh-toolkit REQUIRED)

add_executable(my_project main.cpp)
target_link_libraries(my_project PRIVATE jh::jh-toolkit) # For header-only modules
target_link_libraries(my_project PRIVATE jh::jh-toolkit-impl) # For compiled components

🔎 Usage Example

#include <jh/immutable_str> // or <jh/immutable_str.h>
#include <iostream>

int main() {
    auto pool = jh::pool<jh::immutable_str>();
    const auto str = pool.acquire("Hello, JH Toolkit!");
    std::cout << str->view() << std::endl;
    return 0;
}

---

🔍 Key Modules in JH-Toolkit

🌀 Coroutine-Based Generators (jh::generator<T, U>)

• Lazy evaluation with range-based iteration support.
• Supports send() for interactive coroutine communication.

🔒 Immutable Strings (jh::immutable_str)

• Memory-level enforced immutability and thread safety.
• Lazy hash computation for optimized performance.

🔄 Object Pooling (jh::pool<T> & jh::sim_pool<T, Hash, Eq>)

• Weak pointer-based automatic cleanup, eliminating manual tracking.
• Thread-safe pooling, optimized for immutable types.

📚 Sequence Concept (jh::sequence)

• Provides compile-time validation of sequence-like types for safer API design.

---

🌟 Looking Ahead: Future Updates & Enhancements

The 1.2.x LTS series will continue to receive:

• Cross-platform compatibility refinements.
• Additional test cases and stability improvements.
• Performance optimizations based on real-world usage feedback.

---

🤝 Contributing & Support

We welcome contributions! Feel free to open issues and pull requests on GitHub.

📌 GitHub Repository: JH-Toolkit
📖 Documentation: See the README.md for details.

---

🚀 Thank you for using JH-Toolkit! 🚀

JH-Toolkit v1.1.3

We are excited to announce the release of JH-Toolkit v1.1.3, marking the first stable version in the 1.1.x series! This release introduces powerful enhancements, making jh-toolkit even more robust, efficient, and developer-friendly.

🔥 What's New in JH-Toolkit 1.1.3?

Building upon the solid foundation of 1.0.x, the 1.1.x series brings key improvements:

✅ Range-Based Iteration for Generators

• jh::generator<T, U> now supports iterators (jh::generator<T, U>::iterator, actually an alias for jh::iterator<jh::generator<T, U>>).
• Enables range-based for loops for generators where U == std::monostate.

🔒 Final Classes for Safety

• jh::generator<T, U> and jh::immutable_str are now final, preventing unintended inheritance.

✨ Explicit Copy Prohibition for Generators

• jh::generator<T, U> now only allows move construction, ensuring safe and predictable behavior.

🔧 Stability & Cross-Platform Compatibility

JH-Toolkit v1.1.3 has undergone rigorous testing and is fully verified across multiple platforms:

• Windows: Built and tested with MinGW.
• macOS: Verified with both Clang and GCC.
• Linux: Fully tested using GCC.

This ensures a seamless experience across diverse development environments.

📥 Getting Started

To integrate JH-Toolkit into your project, make sure you have C++20 support and CMake 3.14+ installed.

🔨 Build & Install

cmake -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build
sudo cmake --install build

🏗 CMake Integration

find_package(jh-toolkit REQUIRED)

target_link_libraries(my_project PRIVATE jh::jh-toolkit) # For header-only modules
target_link_libraries(my_project PRIVATE jh::jh-toolkit-impl) # For compiled components

🌟 Looking Ahead: Future Plans for JH-Toolkit 1.2.x & Beyond

We are continuously improving JH-Toolkit to enhance your development experience. Upcoming features include:

• Pooling mechanisms for immutable strings to optimize memory usage (planned for 1.2.x).

🛠 Contribute & Explore

We encourage you to explore the capabilities of JH-Toolkit v1.1.3 and provide feedback. Your contributions and insights are invaluable in shaping the future of this library.

📌 GitHub Repository: JH-Toolkit
📖 Documentation: See the [README.md](https://github.com/JeongHan-Bae/JH-Toolkit/blob/main/README.md) for details.

Thank you for your continued support! 🎉

Happy coding! 🚀

JH-Toolkit v1.0.1

We are thrilled to announce the release of JH-Toolkit v1.0.1 🎉, marking the first stable version in the 1.0.x series. This modern C++20 utility library introduces several powerful features to enhance your development experience.

Key Features:

• Coroutine-Based Generators: Implement Pythonic yield mechanisms in C++20 for efficient lazy evaluation.

• Immutable Strings: Experience true immutability with memory efficiency and thread safety.

• Sequence Concept: Utilize a C++20 concept for compile-time validation of immutable sequences.

Cross-Platform Compatibility:

JH-Toolkit v1.0.1 has been verified on the following platforms:

• Windows: Tested with MinGW.

• macOS: Compatible with both Clang and GCC.

• Linux: Tested with GCC.

This ensures a seamless experience across diverse development environments.

Future Aims in 1.1+.x versions:

• Range-Based for Loop for Generators: We plan to introduce support for range-based for loops in generators to simplify iteration syntax. (might be in 1.1.x

• Pooling for Immutable Strings: Implementing pooling mechanisms to optimize memory usage and performance for immutable strings. (might be for 1.2.x

Getting Started:

To integrate JH-Toolkit into your project, ensure you have C++20 support and CMake 3.14 or higher. Detailed installation instructions and usage examples are available in the README.md.

We encourage you to explore the capabilities of JH-Toolkit v1.0.1 and look forward to your feedback. For any questions or contributions, please visit our GitHub repository.

Happy coding! 🚀