v0.1.5

asf_dyn v0.1.5

This release builds on v0.1.4 with a clearer cache-adopt path for storing dereferenceable smart pointers inside cache_dyn, richer shallow pointer_ops, and an ABI bump to v0_1_5_b0110. Documentation adds a Why ASF section (flexible full-Ptr erasure vs single-handle proxy stacks) and updated pointer/cast specs.

What changed in v0.1.5

• cache_storage_spec<Storage> — maps stored types to cache_ptr geometry and default shallow Ops (unique_ptr / shared_ptr, pointer_trait::ops, …), independent of adopt wrappers
• cache_deref<Ptr> (renamed from proxy_wrap) — reference adopt wrapper for to_dyn: cache buffer holds Ptr, vtable dispatches on the pointee
• Opt-in cache-adopt routing: nested using asf_adopt_proxy = void (presence only; type not checked); same protocol can be implemented on user types
• to_dyn uses cache_ptr_for_storage<Ptr> when Spec is omitted for adopt wrappers (no Spec embedded in the wrapper)
• pointer_ops: unbound ops, duck-typed slots, shallow bool, vtable_of introspection
• Internal cleanup of unused helpers; is_cache_adopt_wrapper fix for move-from-adopt_storage() (Ptr&&)
• Version / ABI: 0.1.5, inline ABI namespace v0_1_5_b0110 (default feature tag b0110)
• README (EN/ZH) and spec docs aligned for cache adopt, adopt_storage, pointee

Breaking / migration (from v0.1.4)

• proxy_wrap → cache_deref
• Wrapper accessors: pointer() → adopt_storage(); no default_cache_spec on the wrapper — use cache_storage_spec or an explicit cache_ptr Spec on to_dyn
• Cache-adopt to_dyn requires asf_adopt_proxy on the wrapper type
• Rebuild all translation units: ABI inline namespace changed v0_1_4_* → v0_1_5_*

Why this release matters

v0.1.5 makes the “smart pointer in SBO cache, methods on the pointee” workflow explicit and extensible without baking buffer layout into a single library wrapper type. It keeps the forward-looking C++26 reflection direction while tightening pointer/c cache ergonomics for proxy-like benchmarks and production-shaped APIs.

Project status

asf_dyn remains an early-stage, standards-dependent library built around the emerging C++26 reflection model. It is not yet a broadly mature production dependency, but it is a deliberate and increasingly coherent codebase with a clear direction and ongoing refinement.

Compatibility and expectations

• Requires a C++26 reflection-capable toolchain
• Primary supported environment remains GCC 16 and related reflection-enabled setups
• Some advanced features remain compiler-sensitive or feature-gated
• API and behavior may continue to evolve as the underlying reflection ecosystem matures
• Do not mix v0.1.4 and v0.1.5 compiled objects in one process (ABI namespace change)

Known limitations

• Requires compiler support for the relevant C++26 reflection features
• Some configuration combinations remain experimental or intentionally restricted
• This is a source-based, header-oriented library rather than a binary distribution
• This release is part of the ongoing 0.1 development trajectory

License

Boost Software License 1.0

v0.1.4

asf_dyn v0.1.4

This release continues the maturation of asf_dyn as a forward-looking C++ library for reflection-based trait and dyn-style polymorphism. Compared with v0.1.3, the main focus of this update is internal refinement of the dispatch and inheritance model, tightening of validation logic, and continued cleanup of the public API surface.

What changed in v0.1.4

• Refined vtable dispatch and function-slot handling for non-null call paths
• Improved inheritance handling by merging redundant direct bases and re-activating truncated paths when appropriate
• Simplified and consolidated internal sub-dyn / iface-trait plumbing
• Tightened empty-state and fit checks around dynamic storage and shallow-path handling
• Cleaned up API naming and hot-path access patterns (ptr() -> raw())
• Continued cleanup of internal implementation details and documentation alignment

Why this release matters

This update is primarily a correctness and maintainability pass rather than a conceptual redesign. It reflects the library’s continued evolution toward a clearer and more robust core model while preserving the forward-looking, C++26 reflection-based direction of the project.

Project status

asf_dyn remains an early-stage, standards-dependent library built around the emerging C++26 reflection model. It is not yet a broadly mature production dependency, but it is a deliberate and increasingly coherent codebase with a clear direction and ongoing refinement.

Compatibility and expectations

• Requires a C++26 reflection-capable toolchain
• Primary supported environment remains GCC 16 and related reflection-enabled setups
• Some advanced features remain compiler-sensitive or feature-gated
• API and behavior may continue to evolve as the underlying reflection ecosystem matures

Known limitations

• Requires compiler support for the relevant C++26 reflection features
• Some configuration combinations remain experimental or intentionally restricted
• This is a source-based, header-oriented library rather than a binary distribution
• This release is part of the ongoing 0.1 development trajectory

License

Boost Software License 1.0

v0.1.3

asf_dyn v0.1.3

This release introduces the initial public version of asf_dyn, a C++26 reflection-based trait system with Rust-like dyn semantics, trait dispatch, and upcasting support.

Overview

asf_dyn provides a header-only C++ library for trait-like polymorphism using GCC reflection. The design centers around:

• Trait definitions via Trait<void> / Trait<T>
• Static handles through iface
• Erased dynamic handles through dyn
• Optional mirror-based field reflection
• Trait upcasting and dispatch through generated vtable metadata

This project is intended for advanced C++ users and library authors exploring reflection-driven polymorphism and low-level dispatch design.

Requirements

• GCC 16 or newer
• C++26 with reflection enabled
• CMake 3.28+
• Link against stdc++exp when using GCC reflection mode

Installation

The library is header-only; include the project's include/ directory in your build and compile with the required reflection flags.

Highlights

• Full Rust-like conceptual mapping for trait/interface/dyn behavior
• Supports dyn upcasting and trait casts across inheritance paths
• Multiple feature configuration modes
  • RTTI support
  • intermediate bind support
  • multi-vtable mode
  • single-inheritance configuration
• Extensive test suite and compile-fail coverage
• Benchmark support against Microsoft proxy
• Bilingual documentation in English and Chinese

Known limitations

• Requires GCC 16 reflection support; broader compiler support is not yet the primary target
• API and behavior may change as the reflection-based model matures
• Certain trait or inheritance patterns are intentionally restricted or require feature-specific configuration
• This is a source-based header library rather than a binary-distributed package

Compatibility

• Primary supported environment: Linux + GCC 16 / Win + MinGW 16
• This release is the initial release and the engineering maturity needs to be verified.

License

Boost Software License 1.0

Notes

This is an early-stage release, it is suitable for library authors and advanced users exploring new trait object models, but users should expect continued change as the design matures.