v0.1.6

🎉 What's New in 0.1.6

This release enhances coroutine utilities with improved reduction operations and complete pipeline support, introduces lightweight array views for efficient data access, and adds debugging tools for better development experience.

🆕 New Features

🧰 Coroutine Enhancements

• Updated coroutine::generator reduction functions: reduce, maximum, minimum, summation
• Completed previously missing pipeline operations for fluent generator chaining

👁️ Array Views

• Introduced lightweight arrayView class for non-owning data access
• Added seamless conversion between array/vector and arrayView
• Support for slicing and subview operations on array views

🔧 Developer Experience

• Implemented GDB pretty-printers for common utility classes
• Enhanced debugging visualization for container types

🔄 Interface Improvements

• Extended array and vector with view() and slice() methods
• Unified array-like container interfaces through array view compatibility

This release focuses on improving data processing pipelines with complete coroutine support and providing efficient zero-copy data access patterns through array views, while making debugging more productive with enhanced visualization tools.

original v0.1.5

🎉 What's New in 0.1.5

This release enhances swap semantics across core utilities, improves container interfaces and concurrency tools, introduces coroutine support, and fixes several key bugs.

🛠️ Build Issues Fixed

• Resolved compilation errors under Clang compiler
• Fixed comparable::operator<=> and std::hash specialization for hashable interfaces not functioning correctly
• Repaired tuple::operator+ compilation errors in certain scenarios

📚 Core Modules Updates

🧱 Containers

• Added swap semantics and std::swap specializations for containers, smart pointers, and allocators
• Implemented hashable interface for container base class iterationStream

🧩 Container Interfaces

• Introduced HashTraits and CmpTraits concepts for hashable and comparable interfaces

🧠 Memory Management

• Enhanced swap semantics for smart pointers (autoPtr, strongPtr, weakPtr)

🧵 Concurrency Module: Vibrant

🔁 Cross-thread Communication

• Added shared consumer model: async::sharedFuture
• Introduced asynchronous pipeline operator: async::operator|

🔒 Synchronization Primitives

• Added semaphore utility: semaphore
• Introduced thread synchronization tool: syncPoint

🆕 New Module: Coroutine Support

✨ Generators & Utilities

• Added C++20 coroutine tool: coroutine::generator
• Extended iterable interface with generator() method and generator-based operations:
  • enumerate, zip, collect, list, join, and more

---

Note: This release ensures better cross-compiler compatibility and enhances functional integration across container, memory, and concurrency modules.

original v0.1.4

🎉 What’s New in 0.1.4
This release introduces the Vibrant concurrency module, enhances container and type utilities, and improves thread safety and compile-time tooling.

🛠️ Build issue Fixed

• This version fixes the CMakeLists.txt configuration issue present in v0.1.3

📚 Core Modules Updates
🧱 Containers

• Added skip list containers: JSet, JMap

• Fixed move-only type compatibility in array, vector, couple, tuple

• Added capacity() method to vector

🧩 Container Interfaces

• Internal refactoring for printable, comparable, and hash interfaces

⚙️ Algorithms

• No changes in this release

📦 Adapters

• Added generic type wrapper: alternative (optional-like type)

🔐 Exception Safety

• No changes in this release

🏗️ Compile-time Tools

• Added types.h with concepts: Printable, Hashable, Transformer

• Added utility classes: none, functionTraits, indexSequence

• Added config.h with platform/compiler detection macros:

• ON_WINDOWS, ON_UNIX, USING_GCC, USING_MSVC

🧠 Memory Management

• Added singleton pattern support: singleton

• Smart pointers (autoPtr, strongPtr, weakPtr) are now thread-safe

🧵 New Module: Vibrant (Concurrency)
🧵 Threads

• Base class: threadBase

• POSIX thread wrapper: pThread

• High-level thread wrapper: thread

🔒 Critical Section Management

• Mutex wrappers: mutexBase, pMutex

• Lock managers: lockGuard, uniqueLock, multiLock

⚡ Thread Synchronization

• Condition variable wrapper: conditionBase, pCondition

⚛️ Atomic Operations

• Atomic variable wrapper: atomic

🔁 Cross-thread Communication

• Producer: async::promise

Consumer: async::future

⏰ Time Utilities

• Time span: time::duration

• Timestamp: time::point

• UTC time: time::UTCTime

📮 Task Scheduling

• Task wrapper: taskBase, task

• Task delegator: taskDelegator

original v0.1.0

🎉 What's New
This is the first official release of the original C++ template library.

📚 Core Modules

🧱 Containers

• Fixed-size containers: array, bitSet
• Dynamic containers: vector, forwardChain, chain, blocksList
• Associative containers: hashMap, treeMap, hashSet, treeSet

🧩 Container Interfaces

• printable (formatted output)
• comparable (custom comparison)
• cloneable (deep copy)
• iterable (range-based iteration)

⚙️ Algorithms

• Boolean algorithms: allOf, anyOf, noneOf, etc.
• Non-modifying algorithms: find, count, equal, etc.
• Modifying algorithms: fill, swap, forEach, etc.
• Sorting: sort, stableSort, introSort

📦 Adapters

• Container adapters: stack, queue, deque, prique
• Algorithm adapters: iterator, iterAdaptor, transform, transformStream, filter, filterStream, comparator

🔐 Exception Safety

• Runtime exceptions: error, outOfBoundError, unSupportedMethodError, allocateError, etc.
• Compile-time diagnostics: staticError

🏗️ Compile-time Tools

• Tuples: couple, tuple

🧠 Memory Management

• Smart pointers: ownerPtr, strongPtr, weakPtr
• Allocators: allocatorBase, allocator, objPoolAllocator
• Deleters: deleterBase, deleter