ScL.Feature

C++20 header-only library. Part of the ScL Toolkit.

ScL.Feature provides scl::wrapper<Value, Executors...> — a composable proxy wrapper that delegates method calls to the held value through a chain of executor templates. Each executor can transparently add cross-cutting behaviour such as copy-on-write semantics, thread safety, or deferred invocation without modifying the wrapped type. Licensed under The Unlicense.

Features

• Wrapper — scl::wrapper<Value, Executors...>, a composable proxy:
  • Delegates all method calls to the held Value through a left-folded executor chain
  • Adjacent duplicate executors in the list are collapsed automatically
  • Defaults to feature::inplace::plain when no executor is specified
• Executors (scl::feature::inplace):
  • inplace::plain — stores Value in-place with zero overhead; serves as the default executor
  • inplace::uninitialized — holds Value in correctly sized and aligned raw storage, enabling deferred (lazy) construction
• Wrapper guard — scl::feature::wrapper_guard<Refer>:
  • RAII guard that calls guard() / unguard() on the executor at construction / destruction
  • Works uniformly for wrapper references and plain value references
  • Exposes value() preserving the cv- and ref-qualifiers of the incoming reference
• Type traits (scl::feature):
  • is_wrapper_v<T> — checks whether T is a wrapper specialization (strips cv-qualifiers)
  • is_compatible_with_v<Expected, Test> — Test is the same as or derived from Expected; for wrapper specialisations with the same executor the check is applied recursively to value types
  • is_compatible_with_part_of_v<Expected, Test> — Expected (a wrapper) recursively contains a value compatible with Test
  • is_part_compatible_with_v<Expected, Test> — Test (a wrapper) recursively contains a value compatible with Expected
• Concepts (scl::feature::concepts):
  • concepts::wrapper<T> — satisfied when T is a wrapper specialization
  • concepts::compatible_with<Expected, T>
  • concepts::compatible_with_part_of<Expected, T>
  • concepts::part_compatible_with<Expected, T>
• Reflection macros (scl/feature/reflection/):
  • SCL_REFLECT_TYPE(Type, Member) — declares the wrapper identity alias required by method reflection
  • SCL_REFLECT_METHOD(method) — generates 16 proxy overloads (8 cv-ref qualifications × 2: deduced and explicit template arguments); each overload is constrained so only overloads that actually exist on the wrapped type are exposed

Requirements

• C++20 compiler (MSVC 19.30+, GCC 13+, Clang 16+)
• CMake 3.20+
• scl::utility (fetched automatically via CMake)

Installation

Add the module as a subdirectory and link against the interface target:

add_subdirectory(module/feature)
target_link_libraries(your_target PRIVATE scl::feature)

Quick example

Reflection

#include <scl/feature/reflection/method.h>
#include <scl/feature/inplace/plain.h>

struct Target {
    short get() &;
    int   get() const &;
    float get() &&;
};

struct MyWrapper {
    Executor<Target> m_executor; // any executor
    SCL_REFLECT_TYPE(MyWrapper, m_executor);

    SCL_REFLECT_METHOD(get)  // generates 16 overloads, 3 survive constraints
};

MyWrapper w{42};
w.get();               // Target::get() &       → short
std::as_const(w).get() // Target::get() const & → int
std::move(w).get();    // Target::get() &&      → float

Doxygen

• GitLab Pages
• GitHub Pages

See also

• CHANGELOG
• CONTRIBUTING