{"id":51116875,"url":"https://github.com/nonstd-lite/indirect-lite","last_synced_at":"2026-06-24T22:33:42.211Z","repository":{"id":65230167,"uuid":"586470945","full_name":"nonstd-lite/indirect-lite","owner":"nonstd-lite","description":"indirect lite – An indirect value-type for C++11 and later in a single-file header-only library  (p1950, p3019)","archived":false,"fork":false,"pushed_at":"2026-06-15T06:24:42.000Z","size":156,"stargazers_count":10,"open_issues_count":1,"forks_count":1,"subscribers_count":1,"default_branch":"master","last_synced_at":"2026-06-15T08:16:54.106Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":"C++","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"bsl-1.0","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/nonstd-lite.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null,"governance":null,"roadmap":null,"authors":null,"dei":null,"publiccode":null,"codemeta":null,"zenodo":null,"notice":null,"maintainers":null,"copyright":null,"agents":null,"dco":null,"cla":null}},"created_at":"2023-01-08T09:01:18.000Z","updated_at":"2026-06-15T06:24:45.000Z","dependencies_parsed_at":"2024-06-01T15:44:55.979Z","dependency_job_id":null,"html_url":"https://github.com/nonstd-lite/indirect-lite","commit_stats":null,"previous_names":["nonstd-lite/indirect-value-lite","martinmoene/indirect-value-lite","nonstd-lite/indirect-lite"],"tags_count":1,"template":false,"template_full_name":null,"purl":"pkg:github/nonstd-lite/indirect-lite","repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nonstd-lite%2Findirect-lite","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nonstd-lite%2Findirect-lite/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nonstd-lite%2Findirect-lite/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nonstd-lite%2Findirect-lite/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/nonstd-lite","download_url":"https://codeload.github.com/nonstd-lite/indirect-lite/tar.gz/refs/heads/master","sbom_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/nonstd-lite%2Findirect-lite/sbom","scorecard":null,"host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":286080680,"owners_count":34752465,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2026-05-26T15:22:16.424Z","status":"online","status_checked_at":"2026-06-24T02:00:07.484Z","response_time":106,"last_error":null,"robots_txt_status":"success","robots_txt_updated_at":"2025-07-24T06:49:26.215Z","robots_txt_url":"https://github.com/robots.txt","online":true,"can_crawl_api":true,"host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2026-06-24T22:33:41.441Z","updated_at":"2026-06-24T22:33:42.205Z","avatar_url":"https://github.com/nonstd-lite.png","language":"C++","funding_links":[],"categories":[],"sub_categories":[],"readme":"# indirect-lite\n\nindirect lite – An indirect value-type for C++11 and later in a single-file header-only library (p1950, p3019)\n\n[![Language](https://img.shields.io/badge/C%2B%2B-11/14/17/20-blue.svg)](https://en.wikipedia.org/wiki/C%2B%2B#Standardization) [![License](https://img.shields.io/badge/license-BSL-blue.svg)](https://opensource.org/licenses/BSL-1.0) [![Build Status](https://github.com/martinmoene/indirect-value-lite/actions/workflows/ci.yml/badge.svg)](https://github.com/martinmoene/indirect-value-lite/actions/workflows/ci.yml) [![Version](https://badge.fury.io/gh/martinmoene%2Findirect-value-lite.svg)](https://github.com/martinmoene/indirect-value-lite/releases) [![download](https://img.shields.io/badge/latest-download-blue.svg)](https://github.com/martinmoene/indirect-value-lite/blob/master/include/nonstd/indirect.hpp) \u003c!--[![Conan](https://img.shields.io/badge/on-conan-blue.svg)](https://conan.io/center/indirect-value-lite) [![Try it on wandbox](https://img.shields.io/badge/on-wandbox-blue.svg)]() --\u003e[![Try it on godbolt online](https://img.shields.io/badge/on-godbolt-blue.svg)](https://godbolt.org/z/s9j8njMM9)\n\n**Contents**  \n\n- [Example usage](#example-usage)\n- [In a nutshell](#in-a-nutshell)\n- [License](#license)\n- [Dependencies](#dependencies)\n- [Installation](#installation)\n- [Synopsis](#synopsis)\n- [Presentations](#presentations)\n- [Other implementations of indirect](#other-implementations-of-indirect)\n- [Notes and references](#notes-and-references)\n- [Appendix](#appendix)\n\n\u003c!-- - [Reported to work with](#reported-to-work-with)\n- [Building the tests](#building-the-tests) --\u003e\n\n## Example usage\n\n```Cpp\n#include \"nonstd/indirect.hpp\"\n#include \u003carray\u003e\n\nusing stdarr = std::array\u003c int, 10 \u003e;\nusing Vector = nonstd::indirect\u003c stdarr \u003e;\n\nint main()\n{\n    Vector src = nonstd::make_indirect\u003cstdarr\u003e( stdarr( {0, 1, 2, 3, 4, 5, 6, 42} ) );\n\n    Vector dst = src;\n\n    return (*dst)[7];  // or:dst.value()[7]\n}\n```\n\n### Compile and run\n\n```Text\n$ g++ -std=c++17 -Wall -I../include/ -o 01-basic.exe 01-basic.cpp \u0026 01-basic.exe\n$ echo $?\n42\n```\n\n## In a nutshell\n\n**indirect lite** is a single-file header-only library to provide `indirect` type proposed for [C++23](http://wg21.link/p1950) for use with C++11 and later. If and when available, the standard library is used, unless [configured](#configuration) otherwise.\n\n**Features and properties of indirect lite** are ease of installation (single header), freedom of dependencies other than the standard library. *indirect lite* shares the approach to in-place tags with any-lite, expected-lite, optional-lite and with variant-lite and these libraries can be used together.\n\n**Limitations of indirect lite** are ... \\[*to be summed up*\\].\n\n## License\n\n*indirect lite* is distributed under the [Boost Software License](https://github.com/martinmoene/indirect-value-lite/blob/master/LICENSE.txt). It contains portions of the reference implementation by the *The Indirect Value Authors*, which has [MIT copyright](https://github.com/jbcoe/indirect/blob/main/LICENSE.txt).\n\n## Dependencies\n\n*indirect lite* has no other dependencies than the [C++ standard library](http://en.cppreference.com/w/cpp/header).\n\n## Installation\n\n*indirect lite* is a single-file header-only library. Put `indirect.hpp` in the [include](include) folder directly into the project source tree or somewhere reachable from your project.\n\n## Synopsis\n\n- [Documentation of `class indirect`](#documentation-of-class-indirect)\n- [Configuration](#configuration)\n\n### Documentation of class indirect\n\n\\[*Envisioned*\\] Depending on the compiler and C++ standard used, *indirect lite* behaves less or more like the standard's version. To get an idea of the capabilities of *indirect lite* with your configuration, look at the output of the [tests](test/indirect.t.cpp), issuing `indirect-main.t --pass @`.\n\nThere's no standard documentation available yet at cppreference for [`class indirect`](https://en.cppreference.com/w/cpp/???/indirect), which is proposed to be part of the [C++ dynamic memory management library](https://en.cppreference.com/w/cpp/memory).\n\n#### Types and values in namespace nonstd\n\n| Purpose               | Type / value                          | Notes                                           |\n| --------------------- | ------------------------------------- | ----------------------------------------------- |\n| Indirect value type   | class **indirect**                    | \u0026nbsp;                                          |\n| Error reporting       | class **bad_indirect_access**         | (extension)                                     |\n| Hash                  | class **std::hash**                   | specialisation (extension)                      |\n| \u0026nbsp;                | \u0026nbsp;                                | \u0026nbsp;                                          |\n| In-place construction | struct **in_place_tag**               | \u0026nbsp;                                          |\n| \u0026nbsp;                | **in_place**                          | select type or index for in-place construction  |\n| \u0026nbsp;                | **in_place_type**                     | select type for in-place construction           |\n| \u0026emsp;(variant)       | **in_place_index**                    | select index for in-place construction          |\n| \u0026nbsp;                | **in_place_t**                        | type or index for in-place construction         |\n| \u0026nbsp;                | **in_place_type_t**                   | type for in-place construction                  |\n| \u0026emsp;(variant)       | **in_place_index_t**                  | index for in-place construction                 |\n| \u0026nbsp;                | **nonstd_lite_in_place**( T)          | macro for alias template in_place               |\n| \u0026nbsp;                | **nonstd_lite_in_place_type**( T)     | macro for alias template in_place_type\u0026lt;T\u003e    |\n| \u0026emsp;(variant)       | **nonstd_lite_in_place_index**( T )   | macro for alias template in_place_index\u0026lt;T\u003e   |\n| \u0026nbsp;                | **nonstd_lite_in_place_t**( T)        | macro for alias template in_place_t             |\n| \u0026nbsp;                | **nonstd_lite_in_place_type_t**( T)   | macro for alias template in_place_type_t\u0026lt;T\u003e  |\n| \u0026emsp;(variant)       | **nonstd_lite_in_place_index_t**( T ) | macro for alias template in_place_index_t\u0026lt;T\u003e |\n\n#### Interface of *indirect lite*\n\n| Kind                 | Std    | Method                                                                                    | Result                       |\n| -------------------- | ------ | ----------------------------------------------------------------------------------------- | ---------------------------- |\n| Types                | \u0026nbsp; | **value_type**                                                                            | T template type              |\n| \u0026nbsp;               | \u0026nbsp; | **copier_type**                                                                           | C template type (extension)  |\n| \u0026nbsp;               | \u0026nbsp; | **deleter_type**                                                                          | D template type (extension)  |\n| Construction         | \u0026nbsp; | constexpr **indirect**() noexcept                                                         | default-construct            |\n| \u0026nbsp;               | \u0026nbsp; | constexpr explicit **indirect**(T * p, C c=C{}, D d=D{})                                  | construct, own given pointer |\n| \u0026nbsp;               | \u0026nbsp; | constexpr **indirect**(indirect const \u0026 other)                                            | copy-construct from other    |\n| \u0026nbsp;               | \u0026nbsp; | constexpr **indirect**(indirect \u0026\u0026 other) noexcept                                        | move-construct from other    |\n| \u0026nbsp;               | \u0026nbsp; | template\u0026lt;class ...T\u003e\u003cbr\u003econstexpr **indirect**(nonstd_lite_in_place_t(T), Ts \u0026\u0026... ts) | in-place construct           |\n| \u0026nbsp;               | \u0026nbsp; | constexpr ~**indirect**()                                                                 | destroy current object       |\n| Assignment\u003cbr\u003e\u0026nbsp; | \u0026nbsp; | constexpr indirect \u0026\u003cbr\u003e**operator=**(indirect const \u0026 rhs)                               | copy-assign from other       |\n| \u0026nbsp;               | \u0026nbsp; | constexpr indirect \u0026\u003cbr\u003e**operator=**(indirect \u0026\u0026 rhs) noexcept                           | move-assign from other       |\n| Modifiers            | \u0026nbsp; | constexpr void **swap**(indirect \u0026 other) noexcept(...)                                   | exchange objects             |\n| Observers            | \u0026nbsp; | constexpr T\u0026 **operator***() \u0026                                                            | owned object                 |\n| \u0026nbsp;               | \u0026nbsp; | constexpr T const \u0026 **operator***() const \u0026                                               | owned object                 |\n| \u0026nbsp;               | \u0026nbsp; | constexpr T \u0026\u0026 **operator***() \u0026\u0026 noexcept                                                | owned object                 |\n| \u0026nbsp;               | \u0026nbsp; | constexpr T const \u0026\u0026 **operator***() const \u0026\u0026 noexcept                                    | owned object                 |\n| \u0026nbsp;               | \u0026nbsp; | constexpr T * **operator-\u003e**() noexcept                                                   | owned object                 |\n| \u0026nbsp;               | \u0026nbsp; | constexpr T const * **operator-\u003e**() const noexcept                                       | owned object                 |\n| \u0026nbsp;               | \u0026nbsp; | constexpr explicit **operator bool**() const noexcept                                     | engaged                      |\n| \u0026nbsp;               | \u0026nbsp; | constexpr bool **has_value**() const noexcept                                             | engaged (extension)          |\n| \u0026nbsp;               | \u0026nbsp; | constexpr T \u0026 **value**() \u0026                                                               | may throw (extension)        |\n| \u0026nbsp;               | \u0026nbsp; | constexpr T const \u0026 **value**() const \u0026                                                   | may throw (extension)        |\n| \u0026nbsp;               | \u0026nbsp; | constexpr T \u0026\u0026 **value**() \u0026\u0026                                                             | may throw (extension)        |\n| \u0026nbsp;               | \u0026nbsp; | constexpr T const \u0026\u0026 **value**() const \u0026\u0026                                                 | may throw (extension)        |\n| \u0026nbsp;               | \u0026nbsp; | constexpr copier_type \u0026 **get_copier**() noexcept                                         | (extension)                  |\n| \u0026nbsp;               | \u0026nbsp; | constexpr copier_type const \u0026 **get_copier**() const noexcept                             | (extension)                  |\n| \u0026nbsp;               | \u0026nbsp; | constexpr deleter_type \u0026 **get_deleter**() noexcept                                       | (extension)                  |\n| \u0026nbsp;               | \u0026nbsp; | constexpr deleter_type const \u0026 **get_deleter**() const noexcept                           | (extension)                  |\n\n#### Algorithms for *indirect lite*\n\n| Kind                           | Std             | Function                                                                                               | Result                       |\n| ------------------------------ | --------------- | ------------------------------------------------------------------------------------------------------ | ---------------------------- |\n| Create\u003cbr\u003e\u0026nbsp;               | \u0026nbsp;          | template\u0026lt;...\u003e constexpr indirect\u003cbr\u003e**make_indirect**(Ts\u0026\u0026... ts)                                   | in-place construct\u003cbr\u003e\u0026nbsp; |\n| \u0026nbsp;                         | \u0026nbsp;          | template\u0026lt;...\u003e constexpr indirect\u003cbr\u003e**allocate_indirect**(std::allocator_arg_t, A \u0026 a, Ts \u0026\u0026... ts) | in-place construct\u003cbr\u003e\u0026nbsp; |\n| Swap                           | \u0026nbsp;          | void **swap**(indirect \u0026 lhs, indirect \u0026 rhs)                                                          | exchange contents            |\n| Relational operators\u003cbr\u003e\u0026nbsp; | \u0026nbsp;          | template\u0026lt;...\u003e constexpr bool\u003cbr\u003eoperator**X**(indirect \u0026 lhs, indirect \u0026 rhs)                       | (extension)                  |\n| \u0026nbsp;                         | \u0026nbsp;          | template\u0026lt;...\u003e constexpr bool\u003cbr\u003eoperator**X**(indirect \u0026 lhs, std::nullptr_t)                       | (extension)                  |\n| \u0026nbsp;                         | \u0026nbsp;          | template\u0026lt;...\u003e constexpr bool\u003cbr\u003eoperator**X**(std::nullptr_t, indirect \u0026 rhs)                       | (extension)                  |\n| Three-way operators            | C++20\u003cbr\u003e\u0026nbsp; | template\u0026lt;...\u003e constexpr bool\u003cbr\u003eoperator**\u0026lt;=\u003e**(...)                                             | (extension)\u003cbr\u003e\u0026nbsp;        |\n\n### Configuration\n\n#### Tweak header\n\nIf the compiler supports [`__has_include()`](https://en.cppreference.com/w/cpp/preprocessor/include), *indirect lite* supports the [tweak header](https://vector-of-bool.github.io/2020/10/04/lib-configuration.html) mechanism. Provide your *tweak header* as `nonstd/indirect.tweak.hpp` in a folder in the include-search-path. In the tweak header, provide definitions as documented below, like `#define indirect_CPLUSPLUS 201103L`.\n\n#### Select `std::indirect` or `nonstd::indirect`\n\nThe C++ standard does not yet provide type `std::indirect`.\n\n\u003c!-- At default, *indirect lite* uses `std::indirect` if it is available and lets you use it via namespace `nonstd`. You can however override this default and explicitly request to use `std::indirect` or indirect lite's `nonstd::indirect` as `nonstd::indirect` via the following macros.\n\n-D\u003cb\u003eindirect\\_CONFIG\\_SELECT\\_indirect\u003c/b\u003e=indirect\\_SELECT\\_indirect\\_NONSTD  \nDefine this to `indirect__CONFIG_SELECT_indirect_STD` to select `std::indirect` as `nonstd::indirect`. Define this to `indirect_SELECT_indirect_NONSTD` to select `nonstd::indirect` as `nonstd::indirect`. Default is undefined, which has the same effect as defining to `indirect_SELECT_indirect_NONSTD` currently (this may change to `indirect_SELECT_indirect_DEFAULT`). --\u003e\n\n#### Standard selection macro\n\n\\-D\u003cb\u003eindirect\\_CPLUSPLUS\u003c/b\u003e=201103L  \nDefine this macro to override the auto-detection of the supported C++ standard, if your compiler does not set the `__cplusplus` macro correctly.\n\n\u003c!--#### Disable exceptions\n\n-D\u003cb\u003eindirect_CONFIG_NO_EXCEPTIONS\u003c/b\u003e=0\nDefine this to 1 if you want to compile without exceptions. If not defined, the header tries and detect if exceptions have been disabled (e.g. via `-fno-exceptions`). Default is undefined. --\u003e\n\n#### Disable extensions\n\n-D\u003cb\u003ensiv\\_CONFIG\\_NO\\_EXTENSIONS\u003c/b\u003e=0  \nDefine this to 1 if you want to compile without extensions with respect to [p1950r2 of October 2022](http://wg21.link/p1950r2). See below. Default is undefined, and all extensions are enabled.\n\n#### Disable reference qualified operators extension\n\n-D\u003cb\u003ensiv\\_CONFIG\\_NO\\_EXTENSION\\_REF\\_QUALIFIED\\_OPERATORS\u003c/b\u003e=0  \nDefine this to 1 if you want to compile without this extension. Default is undefined (extension enabled).\n\n#### Disable `value()` members extension\n\n-D\u003cb\u003ensiv\\_CONFIG\\_NO\\_EXTENSION\\_VALUE\\_MEMBERS\u003c/b\u003e=0  \nDefine this to 1 if you want to compile without this extension. Default is undefined (extension enabled).\n\n#### Disable `get_copier()`, `get_deleter()` extension\n\n-D\u003cb\u003ensiv\\_CONFIG\\_NO\\_EXTENSION\\_GET\\_CPY\\_DEL\\_MEMBERS\u003c/b\u003e=0  \nDefine this to 1 if you want to compile without this extension. Default is undefined (extension enabled).\n\n#### Disable relational operators extension\n\n-D\u003cb\u003ensiv\\_CONFIG\\_NO\\_EXTENSION\\_RELATIONAL\\_OPERATORS\u003c/b\u003e=0  \nDefine this to 1 if you want to compile without this extension. Default is undefined (extension enabled).\n\n#### Disable `std::hash` extension\n\n-D\u003cb\u003ensiv\\_CONFIG\\_NO\\_EXTENSION\\_STD\\_HASH\u003c/b\u003e=0  \nDefine this to 1 if you want to compile without this extension. Default is undefined (extension enabled).  \n\n## Presentations\n\nJonathan Coe. [Vocabulary Types for Composite Class Design](https://youtu.be/sjLRX4WMvlU?si=1_cfQGG2142i5VJo). C++ on Sea 2022.\n\n## Other implementations of indirect\n\nJ.B. Coe. Reference implementation at [value_types](https://github.com/jbcoe/value_types). Value types for composite class design. GitHub.  \nA previous version is archived at [indirect_value](https://github.com/jbcoe/indirect_value).\n\n## Notes and references\n\nW. Brown. [n3339](http://wg21.link/n3339): A Preliminary Proposal for a Deep-Copying Smart Pointer, Walter E. Brown, 2012.  \nJ.B. Coe. [p0201](http://wg21.link/p0201): polymorphic_value: A Polymorphic Value Type for C++, 2022.  \nJ.B. Coe. [p1950](http://wg21.link/p1950): indirect_value: A Free-Store-Allocated Value Type For C++, 2022.  \nJ.B. Coe. [p3019](http://wg21.link/p3019): indirect and polymorphic: Vocabulary Types for Composite Class Design, 2025. P3019r14 was accepted in the Hagenburg meeting in 2025 for inclusion in C++26.  \nJ. Coplien. Advanced C++ Programming Styles and Idioms (Addison-Wesley), James O. Coplien. 1992.  \nC. Ericson. [Memory Optimization, Christer Ericson, Games Developers Conference](http://realtimecollisiondetection.net/pubs/GDC03_Ericson_Memory_Optimization.ppt) (PPT). 2003.  \nR. Grimm. [Visiting a std::variant with the Overload Pattern](https://www.modernescpp.com/index.php/visiting-a-std-variant-with-the-overload-pattern). 2021.  \nH. Hinnant. “[Incomplete types and shared_ptr / unique_ptr](http://howardhinnant.github.io/incomplete.html)”. 2011.  \nM. Knejp. [p0316](http://wg21.link/p0316): allocate_unique and allocator_delete.  \nH. Sutter. \"[Pimpls - Beauty Marks You Can Depend On](http://www.gotw.ca/publications/mill04.htm)\", Herb Sutter. 1998.  \nS. Meyers. Effective Modern C++, Item 22: When using the Pimpl Idiom, define special member functions in the implementation file, Scott Meyers. 2014.  \nA. Upadyshev. [PIMPL, Rule of Zero and Scott Meyers, Andrey Upadyshev](http://oliora.github.io/2015/12/29/pimpl-and-rule-of-zero.html). 2015.  \n\n## Appendix\n\n\u003ca id=\"a1\"\u003e\u003c/a\u003e\n### A.1 Compile-time information\n\nThe version of *indirect lite* is available via tag `[.version]`. The following tags are available for information on the compiler and on the C++ standard library used: `[.compiler]`, `[.stdc++]`, `[.stdlanguage]` and `[.stdlibrary]`.\n\n\u003ca id=\"a2\"\u003e\u003c/a\u003e\n### A.2 indirect lite test specification\n\n\u003cdetails\u003e\n\u003csummary\u003eclick to expand\u003c/summary\u003e\n\u003cp\u003e\n\n```Text\nindirect: Allows to default construct (empty)\nindirect: Allows to construct from pointer\nindirect: Allows to in-place construct from arguments\nindirect: Allows to copy-construct\nindirect: Allows to move-construct\nindirect: Allows to copy-assign\nindirect: Allows to move-assign\nindirect: Allows to swap (value)\nindirect: Allows to swap (copier)\nindirect: Allows to swap (deleter)\nindirect: Allows to obtain value, operator-\u003e()\nindirect: Allows to obtain value, operator-\u003e() const\nindirect: Allows to obtain value, operator*() \u0026\nindirect: Allows to obtain value, operator*() const \u0026\nindirect: Allows to obtain value, operator*() \u0026\u0026\nindirect: Allows to obtain value,operator*() const \u0026\u0026\nindirect: Allows to check if engaged, operator bool()\nindirect: Allows to check if engaged, has_value() [extension]\nindirect: Allows to obtain value, value() \u0026 [extension]\nindirect: Allows to obtain value, value() const \u0026 [extension]\nindirect: Allows to obtain value, value() \u0026\u0026 [extension]\nindirect: Allows to obtain value, value() const \u0026\u0026 [extension]\nindirect: No throw of exception on valid value access, value() \u0026 [extension]\nindirect: No throw of exception on valid value access, value() const \u0026 [extension]\nindirect: No throw of exception on valid value access, value() \u0026\u0026 [extension]\nindirect: No throw of exception on valid value access, value() const \u0026\u0026 [extension]\nindirect: Throws on bad value access, value() \u0026 [extension]\nindirect: Throws on bad value access, value() const \u0026 [extension]\nindirect: Throws on bad value access, value() \u0026\u0026 [extension]\nindirect: Throws on bad value access, value() const \u0026\u0026 [extension]\nindirect: Allows to obtain copier, get_copier() \u0026 [extension]\nindirect: Allows to obtain copier, get_copier() const \u0026 [extension]\nindirect: Allows to obtain deleter, get_deleter() \u0026 [extension]\nindirect: Allows to obtain deleter, get_deleter() const \u0026 [extension]\nindirect: Ensure using minimum space requirements\nindirect: Ensure noexcept of observers\nindirect: Ensure ref- and const-qualifier of observers\nindirect: Ensure properties of bad_indirect_access [extension]\nindirect: Ensure stats of copy and delete type\nindirect: Ensure protection against reentrancy\nindirect: Ensure protection against self-assign\nindirect: Ensure using source copier when copying\nindirect: Ensure working with an incomplete type\nmake_indirect(): Allows to in-place construct an indirect value from parameters\nallocate_indirect(): Allows to in-place construct an indirect value from parameters, with given allocator\nswap(): Allows to swap\nrelational operators: Allows to compare indirect-s [extension]\nrelational operators: Allows to compare indirect with nullptr [extension]\nrelational operators: Allows to compare indirect with value convertible to its value_type [extension]\nrelational operators: Allows to 3-way compare indirect-s [extension]\nrelational operators: Allows to 3-way compare indirect with nullptr [extension]\nrelational operators: Allows to 3-way compare indirect with value convertible to its value_type [extension]\nstd::hash: Allows to hash an indirect [extension]\ntweak header: reads tweak header if supported [tweak]\n```\n\n\u003c/p\u003e\n\u003c/details\u003e\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnonstd-lite%2Findirect-lite","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fnonstd-lite%2Findirect-lite","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fnonstd-lite%2Findirect-lite/lists"}