mirror of
https://github.com/ETLCPP/etl.git
synced 2026-10-28 18:07:10 +08:00
Compare commits
No commits in common. "master" and "20.49.0" have entirely different histories.
@ -120,38 +120,6 @@ The documentation is written in [Goldmark](https://github.com/teekennedy/goldmar
|
||||
Hugo uses [Goldmark](https://github.com/teekennedy/goldmark-markdown) as its default Markdown processor for versions 0.60.0 and newer.
|
||||
It is built into Hugo, providing high-performance and fully [CommonMark](https://commonmark.org/)-compliant rendering, along with support for [GitHub](https://docs.github.com/en/get-started/writing-on-github/getting-started-with-writing-and-formatting-on-github/basic-writing-and-formatting-syntax) Markdown.
|
||||
|
||||
### Documenting Algorithmic Complexity
|
||||
|
||||
When documenting the complexity of an operation, use the `complexity` shortcode instead of writing raw Big-O text.
|
||||
Place it on its own `**Complexity**` lines, right after the `**Description**` line/paragraph, for example:
|
||||
|
||||
```markdown
|
||||
**Description**
|
||||
Returns the number of linked items.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
```
|
||||
|
||||
The shortcode takes two arguments: a complexity class (used to color and label it) and the expression to show
|
||||
inside `O(...)`. The supported classes are:
|
||||
|
||||
```markdown
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
**Complexity**
|
||||
{{< complexity "linear" "N" >}}, where N is number of items in the tree, and assuming comparator is {{< complexity "constant" "1" >}}.
|
||||
**Complexity**
|
||||
{{< complexity "logarithmic" "log N" >}}, where N is number of items in the tree.
|
||||
**Complexity**
|
||||
{{< complexity "linearithmic" "N log N" >}}, where N is number of items in the tree.
|
||||
**Complexity**
|
||||
{{< complexity "polynomial" "N²" >}}, where N is number of items in the tree.
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}} when something, or
|
||||
{{< complexity "exponential" "2ᴺ" >}} some alternative, where N is number of items in the tree.
|
||||
```
|
||||
|
||||
### Starting a New Page
|
||||
|
||||
A template file is provided at `docs/page-template.md` to use as a starting point. Copy it to the
|
||||
|
||||
@ -28,7 +28,7 @@
|
||||
|
||||
|
||||
|
||||
[](https://app.codacy.com/gh/ETLCPP/etl/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
|
||||
[](https://www.codacy.com/manual/jwellbelove/etl?utm_source=github.com&utm_medium=referral&utm_content=ETLCPP/etl&utm_campaign=Badge_Grade)
|
||||
|
||||
[](https://github.com/sponsors/ETLCPP)
|
||||
|
||||
|
||||
@ -40,7 +40,7 @@ type: hextra-home
|
||||
|
||||
<div>
|
||||
<a href="https://etlcpp.github.io/etl/"><img src="https://github.com/ETLCPP/etl/actions/workflows/coverage.yml/badge.svg" alt="coverage"></a>
|
||||
<a href="https://app.codacy.com/gh/ETLCPP/etl/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade"><img src="https://app.codacy.com/project/badge/Grade/c0c29f7b84554166b577e8a98fc18d0b" alt="Codacy Badge"></a>
|
||||
<a href="https://www.codacy.com/manual/jwellbelove/etl"><img src="https://api.codacy.com/project/badge/Grade/3c14cd918ccf40008d0bcd7b083d5946" alt="Codacy"></a>
|
||||
</div>
|
||||
|
||||
<div>
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
title: "About"
|
||||
weight: 3004
|
||||
weight: 3003
|
||||
---
|
||||
|
||||
## About me
|
||||
|
||||
@ -1,59 +0,0 @@
|
||||
---
|
||||
title: "Why CFOs should care about Open Source"
|
||||
description: "The business and financial case for commercially sponsoring the Embedded Template Library (ETL)."
|
||||
date: 2026-09-12
|
||||
weight: 2
|
||||
---
|
||||
|
||||
If your engineering team is using the **Embedded Template Library (ETL)** in commercial products, your company is benefiting from a critical piece of software infrastructure.
|
||||
|
||||
While the ETL is free to use under the permissive MIT license, relying on open-source dependencies in commercial firmware without a formal support mechanism introduces significant **operational and financial risk**.
|
||||
|
||||
This page outlines the business case for transitioning from a passive consumer to a formal commercial sponsor of the ETL.
|
||||
|
||||
## 1. Massive Cost Avoidance (Build vs. Buy)
|
||||
|
||||
Developing, testing, and maintaining a custom, heap-free, deterministic C++ template library internally is a massive financial undertaking. To replicate the functionality, safety, and testing maturity of the ETL would require:
|
||||
|
||||
* At least **1 to 2 senior embedded software engineers** working full-time for over a year.
|
||||
* An estimated internal cost exceeding **$100,000 – $200,000+** in salaries, benefits, and overhead.
|
||||
|
||||
By utilizing the ETL, your company has already saved six figures in upfront R&D costs. Contributing a fraction of those savings back to the project ensures the tool remains actively maintained.
|
||||
|
||||
## 2. Supply Chain Risk Mitigation
|
||||
|
||||
The ETL is an industry-standard library used in automotive, medical, aerospace, and consumer electronics globally. However, it is maintained by a single key architect.
|
||||
|
||||
* **The "Key Person" Risk:** If the project is abandoned due to a lack of financial sustainability, your engineering team is left to maintain a massive, complex codebase alone.
|
||||
* **Toolchain Evolution:** As compiler standards shift (such as transitioning codebases to C++20 and C++23), the library requires ongoing engineering to prevent compilation failures and optimization regressions.
|
||||
|
||||
Sponsorship is not a charitable donation; it is a **risk mitigation premium** that secures the longevity of your product's software foundation.
|
||||
|
||||
## 3. Compliance and Legal Safety
|
||||
|
||||
Many corporate finance and legal departments are hesitant to use software that lacks a clear paper trail or accountability framework.
|
||||
|
||||
* We provide standard, professional **corporate invoices** for accounting and tax compliance.
|
||||
* We accept **direct bank transfers** across multiple major global currencies via standard SWIFT/IBAN channels.
|
||||
* Funding the library ensures it stays compliant with modern software supply chain standards (such as SBOM tracking and security vulnerability scanning).
|
||||
|
||||
## How to Establish Commercial Support
|
||||
|
||||
To simplify corporate procurement, we offer a streamlined vendor onboarding path that fits standard corporate accounting:
|
||||
|
||||
### Production Partner Tier
|
||||
* **Financial Commitment:** An amount such as ~€300 / month (Available as an annual invoice to minimize recurring administrative paperwork).
|
||||
* **Deliverables:** A formalized corporate invoice sent to your accounts payable department, legal recognition of your company as a commercial backer, and direct risk reduction for your engineering stack.
|
||||
|
||||
### Frictionless Corporate Billing (Via GitHub)
|
||||
If your engineering department already uses GitHub Enterprise, you can completely bypass corporate vendor onboarding. You can sponsor the ETL directly through **GitHub Sponsors for Organizations**. This adds the contribution directly to your **existing Microsoft/GitHub corporate invoice**, allowing middle managers to sign off on the expense immediately without involving procurement.
|
||||
|
||||
---
|
||||
|
||||
> "Relying on a critical open-source dependency without supporting its creator is an unmitigated business risk. Securing your software supply chain is a fundamental fiduciary duty."
|
||||
|
||||
---
|
||||
|
||||
For corporate invoicing setups please contact the author directly, or see the instructions [**here**]({{< relref "is-the-etl-free/#how-to-sponsor.md" >}}).
|
||||
|
||||
**{{< safe-email email="corporate.support@etlcpp.com" >}}**
|
||||
@ -1,6 +0,0 @@
|
||||
---
|
||||
title: "Trees"
|
||||
weight: 100
|
||||
---
|
||||
|
||||
Tree like containers.
|
||||
@ -1,560 +0,0 @@
|
||||
---
|
||||
title: "intrusive_avl_tree"
|
||||
weight: 1
|
||||
---
|
||||
|
||||
{{< callout type="info">}}
|
||||
Header: `intrusive_avl_tree.h`
|
||||
Similar to: `std::set` / `std::map` (ordering only, no ownership)
|
||||
{{< /callout >}}
|
||||
|
||||
An intrusive, self-balancing AVL tree.
|
||||
|
||||
```cpp
|
||||
template <typename TValue, size_t ID_ = 0>
|
||||
etl::intrusive_avl_tree
|
||||
```
|
||||
|
||||
`TValue` is the type that contains the actual values. It must derive from
|
||||
`etl::intrusive_avl_tree_base<ID_>::link_type`, exposed as the tree's own
|
||||
`link_type`. Unlike `etl::intrusive_list`/`etl::intrusive_forward_list`,
|
||||
which are templated directly on a link type and expect the node to derive
|
||||
from it publicly, `intrusive_avl_tree` is templated only on `TValue` and an
|
||||
`ID_`. Its `link_type` is a deliberately opaque wrapper around
|
||||
`etl::tree_link<ID_>` that exposes almost nothing as public (or even
|
||||
protected) API, by design, so that inheriting from it imposes as little
|
||||
"intrusive"-ness as possible, avoids name conflicts, and hides implementation
|
||||
details.
|
||||
|
||||
As with the other intrusive containers, an object may inherit multiple
|
||||
`link_type`s with different `ID_` values to be a member of several trees (or
|
||||
lists) at once:
|
||||
|
||||
```cpp
|
||||
typedef etl::intrusive_avl_tree_base<0>::link_type FirstLink;
|
||||
typedef etl::intrusive_avl_tree_base<1>::link_type SecondLink;
|
||||
|
||||
struct Item : public FirstLink, public SecondLink
|
||||
{
|
||||
int value;
|
||||
};
|
||||
|
||||
etl::intrusive_avl_tree<Item, 0> tree0;
|
||||
etl::intrusive_avl_tree<Item, 1> tree1;
|
||||
```
|
||||
|
||||
See also:
|
||||
[Intrusive Links]({{% relref "../../utilities/intrusive-links.md" %}})
|
||||
[intrusive_list]({{% relref "../lists/intrusive-list.md" %}})
|
||||
[intrusive_forward_list]({{% relref "../lists/intrusive-forward-list.md" %}})
|
||||
|
||||
There is no class-level comparator template parameter. Every ordering
|
||||
operation instead takes its own comparator functor at the call site.
|
||||
Lookup functions (`find`, `lower_bound`, `upper_bound`, `find_or_insert`)
|
||||
take a unary comparator accepting a single `const value_type&` and returning
|
||||
an `int`: `>0` if the search target is "greater" than the argument, `0` if
|
||||
found, `<0` if "smaller". The range constructor takes a binary comparator
|
||||
`int(const value_type& lhs, const value_type& rhs)`; `etl::compare<value_type>::cmp`
|
||||
can be used directly if `value_type` defines `<`.
|
||||
|
||||
## Member types
|
||||
|
||||
```cpp
|
||||
link_type (nested, inherited from etl::intrusive_avl_tree_base<ID_>)
|
||||
value_type TValue
|
||||
pointer value_type*
|
||||
const_pointer const value_type*
|
||||
reference value_type&
|
||||
const_reference const value_type&
|
||||
size_type size_t
|
||||
rvalue_reference value_type&& // C++11
|
||||
```
|
||||
|
||||
## The link type
|
||||
|
||||
`TValue` must derive from `link_type`. It has its own set of special member
|
||||
functions that a node author relies on.
|
||||
|
||||
```cpp
|
||||
link_type()
|
||||
```
|
||||
**Description**
|
||||
Default constructor. Leaves the item unlinked.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
link_type(link_type&& other)
|
||||
```
|
||||
**Description**
|
||||
C++11. Constructs a new item by moving `other` into `this`. After
|
||||
construction, `this` replaces `other` in the same tree position that
|
||||
`other` occupied, so no tree balancing is needed. `other` becomes unlinked.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
link_type& operator=(link_type&& other)
|
||||
```
|
||||
**Description**
|
||||
C++11. Assigns `other` by moving it into `this`. Does nothing on
|
||||
self-assignment. After assignment, `this` replaces `other` in the same tree
|
||||
position that `other` occupied; `other` becomes unlinked. `this` might end
|
||||
up in a different tree than it started in.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "logarithmic" "log N" >}} if `this` is already linked to a tree (it has to be erased first, with rebalancing), or
|
||||
{{< complexity "constant" "1" >}} if `this` is not linked, where `N` is number of items in the tree.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
link_type(const link_type&) = delete;
|
||||
link_type& operator=(const link_type&) = delete;
|
||||
```
|
||||
**Description**
|
||||
C++11. Copy construction and assignment are disabled.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
~link_type()
|
||||
```
|
||||
**Description**
|
||||
Might rotate the tree as necessary to keep it balanced. The tree is not the
|
||||
real owner of its nodes' memory - the node's actual owner may destroy it at
|
||||
any time, with or without a prior explicit `erase`. If the link is still
|
||||
linked to a tree when it's destroyed, the destructor unlinks it
|
||||
automatically; otherwise the node's former parent and children would keep
|
||||
dangling pointers to it, breaking the tree and leading to undefined
|
||||
behaviour. This is what makes it safe to embed a tree node in an object
|
||||
whose lifetime is managed elsewhere.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "logarithmic" "log N" >}}, where `N` is number of items in the tree.
|
||||
|
||||
## Constructors
|
||||
|
||||
```cpp
|
||||
etl::intrusive_avl_tree<TValue, ID_>()
|
||||
```
|
||||
**Description**
|
||||
Default constructor. Constructs an empty tree.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
template <typename TIterator, typename TBinaryCompare>
|
||||
etl::intrusive_avl_tree<TValue, ID_>(TIterator first, TIterator last, TBinaryCompare binary_comp)
|
||||
```
|
||||
**Description**
|
||||
Constructs the tree from the range [`first`, `last`) of items, using
|
||||
`binary_comp` to order them. All items in the range must be unlinked
|
||||
initially; if any item is already linked to some other tree, throws
|
||||
`etl::intrusive_avl_tree_value_is_already_linked`, and any items already
|
||||
inserted are unlinked again - it's all or nothing.
|
||||
If duplicates should be kept, `binary_comp` should return a non-zero result
|
||||
even for "equal" items - `<0` prepends a duplicate, `>0` appends one.
|
||||
Returning `0` for equal items keeps only the first of each run of duplicates
|
||||
in the range; the rest are left unlinked. `etl::compare<value_type>::cmp`
|
||||
can be used directly as `binary_comp`.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "linearithmic" "N log N" >}}, where `N` is number of items in the range.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
intrusive_avl_tree(intrusive_avl_tree&&) = default;
|
||||
```
|
||||
**Description**
|
||||
C++11. Move constructor.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
intrusive_avl_tree(const intrusive_avl_tree&) = delete;
|
||||
```
|
||||
**Description**
|
||||
C++11. Copy construction is disabled.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
~intrusive_avl_tree()
|
||||
```
|
||||
**Description**
|
||||
Every remaining node is unlinked; none of the value objects are destroyed,
|
||||
since the tree never owns their memory.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "linear" "N" >}}, where `N` is number of items in the tree.
|
||||
|
||||
## Assignment
|
||||
|
||||
```cpp
|
||||
intrusive_avl_tree& operator=(intrusive_avl_tree&&) = default;
|
||||
```
|
||||
**Description**
|
||||
C++11. Move assignment. Does nothing on self-assignment. All of `this`
|
||||
tree's former items have to be unlinked.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "linear" "N" >}}, where `N` is the size of `this` tree before assignment.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
intrusive_avl_tree& operator=(const intrusive_avl_tree&) = delete;
|
||||
```
|
||||
**Description**
|
||||
C++11. Copy assignment is disabled.
|
||||
|
||||
## Capacity
|
||||
|
||||
```cpp
|
||||
bool empty() const
|
||||
```
|
||||
**Description**
|
||||
Returns `true` if the tree has no linked items.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
size_t size() const
|
||||
```
|
||||
**Description**
|
||||
Returns the number of linked items.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
|
||||
## Iterators
|
||||
|
||||
Only bidirectional `iterator`/`const_iterator` are provided; there is no
|
||||
`reverse_iterator` (use `visit_in_order` with `is_reverse = true` instead).
|
||||
An iterator may be in one of three logical states: it references a real
|
||||
node (`has_value() == true`), it is the terminal sentinel (`it == end()`),
|
||||
or it is "valueless" (`!has_value() && it != end()` - e.g. a
|
||||
default-constructed iterator, or the result of `get_parent()`/`get_child()`
|
||||
when there is no such node).
|
||||
|
||||
```cpp
|
||||
iterator begin()
|
||||
const_iterator begin() const
|
||||
const_iterator cbegin() const
|
||||
```
|
||||
**Description**
|
||||
Returns an iterator to the smallest item. Returns `end()` if the tree is
|
||||
empty.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "logarithmic" "log N" >}}, where `N` is number of items in the tree.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
iterator end()
|
||||
const_iterator end() const
|
||||
const_iterator cend() const
|
||||
```
|
||||
**Description**
|
||||
Returns an iterator to the terminal sentinel.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
iterator min()
|
||||
const_iterator min() const
|
||||
```
|
||||
**Description**
|
||||
Equivalent to `begin()`.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "logarithmic" "log N" >}}, where `N` is number of items in the tree.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
iterator max()
|
||||
const_iterator max() const
|
||||
```
|
||||
**Description**
|
||||
Equivalent to `--end()`.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "logarithmic" "log N" >}}, where `N` is number of items in the tree.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
iterator& operator++()
|
||||
iterator operator++(int)
|
||||
```
|
||||
**Description**
|
||||
Advances the iterator to the next ("greater") item.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}} amortized,
|
||||
{{< complexity "logarithmic" "log N" >}} worst-case, where `N` is number of items in the tree.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
iterator& operator--()
|
||||
iterator operator--(int)
|
||||
```
|
||||
**Description**
|
||||
Moves the iterator to the previous ("smaller") item.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}} amortized,
|
||||
{{< complexity "logarithmic" "log N" >}} worst-case, where `N` is number of items in the tree.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
reference operator*() const
|
||||
pointer operator->() const
|
||||
pointer get() const
|
||||
```
|
||||
**Description**
|
||||
Dereferences an iterator that has a value. `operator*`/`operator->` throw
|
||||
`etl::intrusive_avl_tree_iterator_exception` if `has_value()` is `false`.
|
||||
`get()` returns `nullptr` instead of throwing.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
bool has_value() const
|
||||
explicit operator bool() const
|
||||
```
|
||||
**Description**
|
||||
Returns `true` if the iterator references a real node.
|
||||
|
||||
## Advanced traversal
|
||||
|
||||
These are normally only needed for advanced traversal.
|
||||
|
||||
```cpp
|
||||
iterator get_root()
|
||||
const_iterator get_root() const
|
||||
```
|
||||
**Description**
|
||||
Returns an iterator to the root node. Valueless (`has_value() == false`) if
|
||||
the tree is empty.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
int_fast8_t get_balance_factor() const
|
||||
```
|
||||
**Description**
|
||||
Returns the node's AVL balance factor: `-1`, `0` or `+1`.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
iterator get_parent() const
|
||||
```
|
||||
**Description**
|
||||
Returns an iterator to the node's parent. Valueless if there is no parent.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
iterator get_child(bool is_right) const
|
||||
```
|
||||
**Description**
|
||||
Returns an iterator to the node's left (`is_right == false`) or right
|
||||
(`is_right == true`) child. Valueless if there is no such child.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
|
||||
## Lookup
|
||||
|
||||
```cpp
|
||||
template <typename TCompare>
|
||||
iterator find(TCompare comp)
|
||||
template <typename TCompare>
|
||||
const_iterator find(TCompare comp) const
|
||||
```
|
||||
**Description**
|
||||
Finds an item using the unary comparator `comp`. Returns `end()` if there
|
||||
is no matching item.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "logarithmic" "log N" >}}, where `N` is number of items in the tree,
|
||||
and assuming `comp` is {{< complexity "constant" "1" >}}.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
template <typename TCompare>
|
||||
iterator lower_bound(TCompare comp)
|
||||
template <typename TCompare>
|
||||
const_iterator lower_bound(TCompare comp) const
|
||||
```
|
||||
**Description**
|
||||
Returns an iterator to the first item that compares as "not less" than the
|
||||
target of `comp`. Returns `end()` if no such item exists.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "logarithmic" "log N" >}}, where `N` is number of items in the tree,
|
||||
and assuming `comp` is {{< complexity "constant" "1" >}}.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
template <typename TCompare>
|
||||
iterator upper_bound(TCompare comp)
|
||||
template <typename TCompare>
|
||||
const_iterator upper_bound(TCompare comp) const
|
||||
```
|
||||
**Description**
|
||||
Returns an iterator to the first item that compares as "greater" than the
|
||||
target of `comp`. Returns `end()` if no such item exists.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "logarithmic" "log N" >}}, where `N` is number of items in the tree,
|
||||
and assuming `comp` is {{< complexity "constant" "1" >}}.
|
||||
|
||||
## Modifiers
|
||||
|
||||
```cpp
|
||||
template <typename TCompare, typename TFactory>
|
||||
etl::pair<iterator, bool> find_or_insert(TCompare comp, TFactory factory)
|
||||
```
|
||||
**Description**
|
||||
Finds an existing item using the unary comparator `comp`; if not found,
|
||||
calls `factory()` (no arguments) and inserts the item it returns at the
|
||||
position where the search stopped. This operation never invalidates
|
||||
existing iterators, though depending on where the new item was linked,
|
||||
existing iterators may skip over it.
|
||||
`factory` must return the address of the new value (castable to
|
||||
`link_type*`). If it returns `nullptr`, the tree is left unmodified and the
|
||||
result iterator is valueless. If the returned value is already linked to
|
||||
any tree, throws `etl::intrusive_avl_tree_value_is_already_linked`.
|
||||
Returns a pair of: an iterator to the found or inserted item (never `end()`,
|
||||
but may be valueless), and a `bool` that is `true` if the tree was modified.
|
||||
If duplicates are wanted, `comp` should return a non-zero result even for
|
||||
"equal" items - `+1` appends after existing duplicates, `-1` prepends
|
||||
before them.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "logarithmic" "log N" >}}, where `N` is number of items in the tree,
|
||||
and assuming `comp` and `factory` are {{< complexity "constant" "1" >}}.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
iterator erase(iterator position)
|
||||
iterator erase(const_iterator position)
|
||||
```
|
||||
**Description**
|
||||
Erases the item at `position`, including tree rebalancing. `position` must
|
||||
reference a real item (asserts/throws
|
||||
`etl::intrusive_avl_tree_iterator_exception` otherwise) and must originate
|
||||
from this tree instance. Invalidates any existing iterator to the erased
|
||||
item, but no others. Returns an iterator to the next node.
|
||||
Use `clear()` instead if every item needs to be erased - no rebalancing is
|
||||
involved.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "logarithmic" "log N" >}}, where `N` is number of items in the tree.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
void clear()
|
||||
```
|
||||
**Description**
|
||||
Unlinks every item, leaving the tree empty. Invalidates all existing
|
||||
iterators. This is cheaper than calling `erase` on every item, which would
|
||||
cost {{< complexity "linearithmic" "N log N" >}} once intermediate
|
||||
rebalancing is taken into account.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "linear" "N" >}}, where `N` is number of items in the tree.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
void swap(intrusive_avl_tree& other)
|
||||
friend void swap(intrusive_avl_tree& lhs, intrusive_avl_tree& rhs)
|
||||
```
|
||||
**Description**
|
||||
Swaps the contents of two trees. Does nothing on self-swap.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "constant" "1" >}}
|
||||
|
||||
## Traversal
|
||||
|
||||
Each of these visits every item exactly once, without recursion, and has a
|
||||
`const` overload. The visitor must not modify the tree during visitation.
|
||||
|
||||
```cpp
|
||||
template <typename Visitor>
|
||||
void visit_in_order(bool is_reverse, Visitor visitor)
|
||||
```
|
||||
**Description**
|
||||
Visits every item in sorted order. `is_reverse` selects ascending (`false`)
|
||||
or descending (`true`) order.
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "linear" "N" >}}, where `N` is number of items in the tree.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
template <typename Visitor>
|
||||
void visit_pre_order(bool is_reverse, Visitor visitor)
|
||||
```
|
||||
**Description**
|
||||
Visits every item in pre-order (parent before children).
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "linear" "N" >}}, where `N` is number of items in the tree.
|
||||
|
||||
---
|
||||
|
||||
```cpp
|
||||
template <typename Visitor>
|
||||
void visit_post_order(bool is_reverse, Visitor visitor)
|
||||
```
|
||||
**Description**
|
||||
Visits every item in post-order (children before parent).
|
||||
|
||||
**Complexity**
|
||||
{{< complexity "linear" "N" >}}, where `N` is number of items in the tree.
|
||||
|
||||
## Exceptions
|
||||
|
||||
```cpp
|
||||
intrusive_avl_tree_exception // base exception
|
||||
intrusive_avl_tree_iterator_exception // invalid iterator use
|
||||
intrusive_avl_tree_value_is_already_linked // item already linked to a tree
|
||||
```
|
||||
@ -1,6 +1,6 @@
|
||||
---
|
||||
title: "Sponsors of the ETL"
|
||||
weight: 3
|
||||
weight: 3002
|
||||
---
|
||||
|
||||
A special thank you to all of our past and current sponsors. Your generosity directly funds the continuous development and maintenance of the ETL.
|
||||
|
||||
@ -13,11 +13,6 @@ A quick introduction to containers.
|
||||
|
||||
---
|
||||
|
||||
[Intrusive AVL Tree](./intrusive-avl-tree-tutorial)
|
||||
Ordering objects that already exist, without a second container.
|
||||
|
||||
---
|
||||
|
||||
[observer](./observer-tutorial)
|
||||
A templated set of classes to allow easier implementation of the observer pattern.
|
||||
|
||||
|
||||
@ -1,210 +0,0 @@
|
||||
---
|
||||
title: "Intrusive AVL Tree"
|
||||
---
|
||||
|
||||
A tutorial on how `etl::intrusive_avl_tree` can give ordered,
|
||||
{{< complexity "logarithmic" "log N" >}} access to objects that already
|
||||
exist elsewhere, without a second container to track them.
|
||||
|
||||
## Overview
|
||||
|
||||
Imagine a set of driver/sensor tasks, each owned by its own subsystem. They
|
||||
are created and destroyed at unpredictable times as modules attach and
|
||||
detach, so there is no compile-time upper bound on how many exist at once.
|
||||
A scheduler needs to visit the tasks that are currently due, in ascending
|
||||
deadline order, on every tick.
|
||||
|
||||
A normal fixed-capacity ordered container (`etl::set`/`etl::map`) would need
|
||||
a second, separately-sized place to store pointers to these tasks. Instead,
|
||||
embedding an `etl::intrusive_avl_tree` link directly into each task object
|
||||
gives the scheduler ordered, {{< complexity "logarithmic" "log N" >}}
|
||||
access to exactly the tasks that exist right now - nothing more is
|
||||
allocated, and nothing needs to be kept in sync by hand. That's the payoff of "intrusive": the tree links the
|
||||
objects that already exist, rather than storing copies of them.
|
||||
|
||||
The example below also demonstrates two things that fall out of the design
|
||||
for free:
|
||||
- **Move support.** When the `std::vector` that owns the tasks reallocates,
|
||||
every task is moved into new storage - and each move takes over its
|
||||
task's exact tree position, with no rebalancing and no code of its own.
|
||||
- **Safe removal without an explicit `erase()` call.** Removing a task's
|
||||
owning object removes it from the schedule too, with no dangling entry
|
||||
left behind - whether that's because the object is destroyed while still
|
||||
linked (`link_type`'s destructor unlinks it automatically), or, as in
|
||||
this example, because `std::vector::erase` move-assigns another task over
|
||||
it (`link_type`'s move assignment unlinks `this` before taking over the
|
||||
moved-from tree position).
|
||||
|
||||
## Example
|
||||
|
||||
```cpp
|
||||
#include "etl/intrusive_avl_tree.h"
|
||||
|
||||
#include <cstdint>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <algorithm>
|
||||
|
||||
// A driver/sensor task that already exists as a long-lived object owned by
|
||||
// its own subsystem. Inheriting from the tree's link_type is all it takes
|
||||
// to make it schedulable - no separate fixed-capacity container is needed
|
||||
// to track which tasks exist.
|
||||
class SensorTask : public etl::intrusive_avl_tree_base<0>::link_type
|
||||
{
|
||||
public:
|
||||
SensorTask(uint32_t id_, uint32_t deadline_, uint32_t period_)
|
||||
: id(id_), deadline(deadline_), period(period_)
|
||||
{
|
||||
}
|
||||
|
||||
// Orders primarily by deadline; ties are broken by id so two tasks due
|
||||
// on the same tick still occupy distinct tree positions.
|
||||
struct Locate
|
||||
{
|
||||
uint32_t target_deadline;
|
||||
uint32_t target_id;
|
||||
|
||||
int operator()(const SensorTask& node) const
|
||||
{
|
||||
if (target_deadline != node.deadline)
|
||||
{
|
||||
return (target_deadline < node.deadline) ? -1 : 1;
|
||||
}
|
||||
if (target_id != node.id)
|
||||
{
|
||||
return (target_id < node.id) ? -1 : 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
uint32_t id;
|
||||
uint32_t deadline; // next tick at which this task must be serviced
|
||||
uint32_t period;
|
||||
};
|
||||
|
||||
typedef etl::intrusive_avl_tree<SensorTask> Schedule;
|
||||
|
||||
// The only place a task gets linked - called whenever a module attaches,
|
||||
// or whenever a task is rescheduled after being serviced.
|
||||
void schedule_task(Schedule& schedule, SensorTask& task)
|
||||
{
|
||||
schedule.find_or_insert(SensorTask::Locate{ task.deadline, task.id },
|
||||
[&task] { return &task; });
|
||||
}
|
||||
|
||||
// Visits every currently-due task in ascending deadline order, services it,
|
||||
// then reschedules it at its next deadline.
|
||||
void service_due_tasks(Schedule& schedule, uint32_t now)
|
||||
{
|
||||
for (auto it = schedule.begin(); (it != schedule.end()) && (it->deadline <= now); )
|
||||
{
|
||||
SensorTask& task = *it;
|
||||
it = schedule.erase(it); // O(log N), rebalances
|
||||
|
||||
std::cout << "servicing task " << task.id << " (was due at " << task.deadline << ")\n";
|
||||
|
||||
task.deadline = now + task.period;
|
||||
schedule_task(schedule, task); // reschedule at the new deadline
|
||||
}
|
||||
}
|
||||
|
||||
void print_schedule(const Schedule& schedule)
|
||||
{
|
||||
for (auto it = schedule.begin(); it != schedule.end(); ++it)
|
||||
{
|
||||
std::cout << " task " << it->id << " due at " << it->deadline << "\n";
|
||||
}
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
Schedule schedule;
|
||||
|
||||
// Driver registry: a plain std::vector that a subsystem uses to own its
|
||||
// tasks for whatever reason it already needs to - the tree does not
|
||||
// require this vector to exist, it's just a stand-in for "wherever the
|
||||
// real owner happens to keep the object".
|
||||
std::vector<SensorTask> driver_registry;
|
||||
driver_registry.reserve(2);
|
||||
|
||||
driver_registry.emplace_back(1, 100, 1000);
|
||||
schedule_task(schedule, driver_registry.back());
|
||||
|
||||
driver_registry.emplace_back(2, 300, 1000);
|
||||
schedule_task(schedule, driver_registry.back());
|
||||
|
||||
std::cout << "Initial schedule (ascending deadline):\n";
|
||||
print_schedule(schedule);
|
||||
|
||||
std::cout << "\nschedule.size() before growth: " << schedule.size() << "\n";
|
||||
|
||||
// driver_registry.reserve()'d capacity was 2; this emplace_back forces a
|
||||
// reallocation. std::vector move-constructs every existing SensorTask
|
||||
// into the new storage. Each move steals its task's exact tree position
|
||||
// (O(1), no rebalancing) - the tree needs no code of its own to survive
|
||||
// the underlying storage moving.
|
||||
driver_registry.emplace_back(3, 200, 1100);
|
||||
schedule_task(schedule, driver_registry.back());
|
||||
|
||||
std::cout << "schedule.size() after growth: " << schedule.size() << "\n\n";
|
||||
|
||||
std::cout << "Schedule after growth (still correctly ordered):\n";
|
||||
print_schedule(schedule);
|
||||
|
||||
std::cout << "\nServicing due tasks at tick 250:\n";
|
||||
service_due_tasks(schedule, 250);
|
||||
|
||||
std::cout << "\nSchedule after servicing:\n";
|
||||
print_schedule(schedule);
|
||||
|
||||
// Unplugging a module removes its SensorTask from driver_registry. Task 2
|
||||
// isn't the last element, so std::vector::erase() doesn't just destroy it
|
||||
// in place: it move-assigns the following element (task 3) into task 2's
|
||||
// slot, then destroys the now-duplicate last slot. That move-assignment
|
||||
// is SensorTask's (implicitly-generated) one, which calls
|
||||
// link_type::operator=(link_type&&): it first unlinks *this* - task 2's
|
||||
// slot, still linked at deadline 300 - from the tree, then takes over
|
||||
// task 3's tree position. The destructor that runs afterwards, on the
|
||||
// vacated last slot, fires on an already-unlinked, moved-from object, so
|
||||
// it has nothing left to do - no explicit schedule.erase() call is made
|
||||
// here, and no dangling entry is left behind.
|
||||
std::cout << "\nschedule.size() before unplugging task 2: " << schedule.size() << "\n";
|
||||
|
||||
auto pos = std::find_if(driver_registry.begin(), driver_registry.end(),
|
||||
[](const SensorTask& t) { return t.id == 2; });
|
||||
driver_registry.erase(pos); // move-assigns task 3 over task 2, unlinking task 2
|
||||
|
||||
std::cout << "schedule.size() after unplugging task 2: " << schedule.size() << "\n";
|
||||
|
||||
return 0;
|
||||
}
|
||||
```
|
||||
|
||||
## Program output
|
||||
|
||||
```
|
||||
Initial schedule (ascending deadline):
|
||||
task 1 due at 100
|
||||
task 2 due at 300
|
||||
|
||||
schedule.size() before growth: 2
|
||||
schedule.size() after growth: 3
|
||||
|
||||
Schedule after growth (still correctly ordered):
|
||||
task 1 due at 100
|
||||
task 3 due at 200
|
||||
task 2 due at 300
|
||||
|
||||
Servicing due tasks at tick 250:
|
||||
servicing task 1 (was due at 100)
|
||||
servicing task 3 (was due at 200)
|
||||
|
||||
Schedule after servicing:
|
||||
task 2 due at 300
|
||||
task 1 due at 1250
|
||||
task 3 due at 1350
|
||||
|
||||
schedule.size() before unplugging task 2: 3
|
||||
schedule.size() after unplugging task 2: 2
|
||||
```
|
||||
@ -297,8 +297,6 @@ template <const size_t ID_>
|
||||
struct tree_link
|
||||
```
|
||||
|
||||
`etl::intrusive_avl_tree` is built on top of `tree_link` - see [intrusive_avl_tree]({{% relref "../containers/trees/intrusive-avl-tree.md" %}}).
|
||||
|
||||
### Template parameters
|
||||
```cpp
|
||||
const size_t ID_
|
||||
|
||||
@ -1,6 +1,222 @@
|
||||
/**********************/
|
||||
/* .highlight .chroma */
|
||||
/**********************/
|
||||
/* Definitions for light mode */
|
||||
html:not(.dark) .highlight .chroma .c1
|
||||
{
|
||||
color: forestgreen !important;
|
||||
}
|
||||
|
||||
html:not(.dark) .highlight .chroma .cp,
|
||||
html:not(.dark) .highlight .chroma .cpf {
|
||||
color: mediumslateblue !important;
|
||||
}
|
||||
|
||||
html:not(.dark) h1 {
|
||||
color: white !important;
|
||||
width: 100%;
|
||||
background-color: coral !important;
|
||||
border: width 0.15rem solid rgb(163, 81, 51) !important;
|
||||
padding: 0.5rem 0.5rem !important;
|
||||
}
|
||||
|
||||
html:not(.dark) h2 {
|
||||
color: royalblue !important;
|
||||
border-bottom: 3px solid black !important;
|
||||
}
|
||||
|
||||
html:not(.dark) h3,
|
||||
html:not(.dark) h4
|
||||
{
|
||||
color: darkgoldenrod !important;
|
||||
border-bottom: 2px solid darkgrey !important;
|
||||
}
|
||||
|
||||
html:not(.dark) p {
|
||||
color: black !important;
|
||||
}
|
||||
|
||||
html:not(.dark) dl,
|
||||
html:not(.dark) dl dt code,
|
||||
html:not(.dark) dl dd {
|
||||
color: black !important;
|
||||
background-color: #eeeeee !important;
|
||||
}
|
||||
|
||||
html:not(.dark) code,
|
||||
html:not(.dark) pre,
|
||||
html:not(.dark) pre code {
|
||||
color: black !important;
|
||||
background-color: #eeeeee !important;
|
||||
}
|
||||
|
||||
html:not(.dark) hr {
|
||||
background-color: #eeeeee !important;
|
||||
}
|
||||
|
||||
html:not(.dark) .hx\:font-extrabold {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-size: 1.6rem !important;
|
||||
color: royalblue !important;
|
||||
}
|
||||
|
||||
/* inactive */
|
||||
html:not(.dark) .hx\:text-gray-500 {
|
||||
color: black !important;
|
||||
}
|
||||
|
||||
/* active */
|
||||
html:not(.dark) .hextra-sidebar-active-item {
|
||||
color: black !important;
|
||||
}
|
||||
|
||||
html:not(.dark) .content p.label-text {
|
||||
color: darkgoldenrod !important;
|
||||
}
|
||||
|
||||
/* Regular item hover */
|
||||
html:not(.dark) .hextra-sidebar-item a:hover,
|
||||
html:not(.dark) .hextra-sidebar-item a:hover span {
|
||||
background-color: rgb(250, 195, 175) !important;
|
||||
color: black !important;
|
||||
}
|
||||
|
||||
/* Active item default + hover - must come AFTER regular hover */
|
||||
html:not(.dark) .hextra-sidebar-item[data-active="true"] a,
|
||||
html:not(.dark) .hextra-sidebar-item[data-active="true"] a span,
|
||||
html:not(.dark) .hextra-sidebar-item[data-active="true"] a:hover,
|
||||
html:not(.dark) .hextra-sidebar-item[data-active="true"] a:hover span {
|
||||
background-color: coral !important;
|
||||
color: white !important;
|
||||
}
|
||||
|
||||
|
||||
/* Definitions for dark mode */
|
||||
html.dark .highlight .chroma .c1
|
||||
{
|
||||
color: lightgreen !important;
|
||||
}
|
||||
|
||||
html.dark .highlight .chroma .cp,
|
||||
html.dark.highlight .chroma .cpf {
|
||||
color: lightsteelblue !important;
|
||||
}
|
||||
|
||||
html.dark body {
|
||||
background-color: #1e1e1e !important;
|
||||
}
|
||||
|
||||
html.dark main {
|
||||
background-color: #252525 !important;
|
||||
}
|
||||
|
||||
html.dark .hx\:dark\:shadow-\[0_-12px_16px_\#111\] {
|
||||
box-shadow: 0 -12px 16px #1e1e1e !important;
|
||||
}
|
||||
|
||||
html.dark .hx\:dark\:bg-dark {
|
||||
background-color: #1e1e1e !important;
|
||||
border-color: grey !important;
|
||||
}
|
||||
|
||||
html.dark h1
|
||||
{
|
||||
color: white !important;
|
||||
width: 100%;
|
||||
background-color: rgb(177, 87, 54) !important;
|
||||
padding: 0.5rem 0.5rem !important;
|
||||
}
|
||||
|
||||
html.dark h2 {
|
||||
color: #7099c7 !important;
|
||||
border-bottom: 2px solid #c0c0c0 !important;
|
||||
}
|
||||
|
||||
html.dark h3,
|
||||
html.dark h4 {
|
||||
color: lightgreen !important;
|
||||
border-bottom: 2px solid #505050 !important;
|
||||
}
|
||||
|
||||
html.dark p {
|
||||
color: #c0c0c0 !important;
|
||||
}
|
||||
|
||||
html.dark p strong {
|
||||
color: #c4c3a6;
|
||||
}
|
||||
|
||||
html.dark dl,
|
||||
html.dark dl dt code,
|
||||
html.dark dl dd {
|
||||
color: #c0c0c0 !important;
|
||||
background-color: #444444 !important;
|
||||
}
|
||||
|
||||
html.dark code,
|
||||
html.dark pre,
|
||||
html.dark pre code {
|
||||
color: #c0c0c0 !important;
|
||||
background-color: #444444 !important;
|
||||
}
|
||||
|
||||
html.dark hr {
|
||||
background-color: #505050 !important;
|
||||
}
|
||||
|
||||
html.dark .hx\:font-extrabold {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-size: 1.6rem !important;
|
||||
color: #7099c7 !important;
|
||||
}
|
||||
|
||||
/* inactive */
|
||||
html.dark .hx\:text-gray-500 {
|
||||
color: #c0c0c0 !important;
|
||||
}
|
||||
|
||||
/* active */
|
||||
html.dark .hextra-sidebar-active-item {
|
||||
color: #c0c0c0 !important;
|
||||
}
|
||||
|
||||
html.dark .hextra-code-block .highlight .chroma span.p {
|
||||
color: #c0c0c0;
|
||||
}
|
||||
|
||||
html.dark .content p.label-text {
|
||||
color: salmon !important;
|
||||
}
|
||||
|
||||
/* Regular item hover */
|
||||
html.dark .hextra-sidebar-item a:hover,
|
||||
html.dark .hextra-sidebar-item a:hover span {
|
||||
background-color: rgb(250, 195, 175) !important;
|
||||
color: black !important;
|
||||
}
|
||||
|
||||
/* Active item default + hover - must come AFTER regular hover */
|
||||
html.dark .hextra-sidebar-item[data-active="true"] a,
|
||||
html.dark .hextra-sidebar-item[data-active="true"] a span,
|
||||
html.dark .hextra-sidebar-item[data-active="true"] a:hover,
|
||||
html.dark .hextra-sidebar-item[data-active="true"] a:hover span {
|
||||
background-color: rgb(177, 87, 54) !important;
|
||||
color: #e0e0e0 !important;
|
||||
}
|
||||
|
||||
/* Common definitions */
|
||||
|
||||
@font-face {
|
||||
font-family: Roboto;
|
||||
src: url('/fonts/roboto-v51-latin-regular.woff2') format('woff2');
|
||||
font-weight:500;
|
||||
font-style: normal;
|
||||
}
|
||||
|
||||
@font-face {
|
||||
font-family: 'Roboto Mono';
|
||||
src: url('/fonts/roboto-mono-v31-latin-500.woff2') format('woff2');
|
||||
font-weight: nornal;
|
||||
font-style: normal;
|
||||
}
|
||||
|
||||
.highlight .chroma .k,
|
||||
.highlight .chroma .kc,
|
||||
.highlight .chroma .kd,
|
||||
@ -17,21 +233,64 @@
|
||||
font-style: normal !important;
|
||||
}
|
||||
|
||||
html.dark .highlight .chroma .cp,
|
||||
html.dark.highlight .chroma .cpf {
|
||||
color: lightgreen !important;
|
||||
color: lightsteelblue !important;
|
||||
.hx\:mb-0 {
|
||||
display: block;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
html:not(.dark) .highlight .chroma .cp,
|
||||
html:not(.dark) .highlight .chroma .cpf {
|
||||
.hextra-code-block {
|
||||
margin-top: 0.5rem !important;
|
||||
|
||||
}
|
||||
|
||||
/* .highlight .chroma .c1
|
||||
{
|
||||
color: forestgreen !important;
|
||||
color: mediumslateblue !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* h1 */
|
||||
/***********************/
|
||||
.highlight .chroma .cp,
|
||||
.highlight .chroma .cpf {
|
||||
color: mediumslateblue !important;
|
||||
} */
|
||||
|
||||
html.dark .hextra-code-block .highlight .chroma .cs,
|
||||
html.dark .hextra-code-block .highlight .chroma .cp,
|
||||
html.dark .hextra-code-block .highlight .chroma .cpf {
|
||||
font-weight: normal;
|
||||
}
|
||||
|
||||
.badges {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 4px;
|
||||
justify-content: flex-start;
|
||||
margin-top: 1rem;
|
||||
}
|
||||
|
||||
.badges p {
|
||||
display: contents;
|
||||
margin: 0;
|
||||
}
|
||||
|
||||
.badges div {
|
||||
width: 100%;
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 4px;
|
||||
}
|
||||
|
||||
.content ul li {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-style: normal !important;
|
||||
font-weight: normal !important;
|
||||
font-size: 1.1rem !important;
|
||||
}
|
||||
|
||||
.err {
|
||||
background-color: transparent !important;
|
||||
color: inherit !important;
|
||||
}
|
||||
|
||||
h1 {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-style: i !important;
|
||||
@ -42,25 +301,6 @@ h1 {
|
||||
border-radius: 0.5rem !important;
|
||||
}
|
||||
|
||||
html.dark h1
|
||||
{
|
||||
color: white !important;
|
||||
width: 100%;
|
||||
background-color: rgb(177, 87, 54) !important;
|
||||
padding: 0.5rem 0.5rem !important;
|
||||
}
|
||||
|
||||
html:not(.dark) h1 {
|
||||
color: white !important;
|
||||
width: 100%;
|
||||
background-color: coral !important;
|
||||
border: width 0.15rem solid rgb(163, 81, 51) !important;
|
||||
padding: 0.5rem 0.5rem !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* h2 */
|
||||
/***********************/
|
||||
h2 {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-style: normal !important;
|
||||
@ -70,19 +310,6 @@ h2 {
|
||||
margin-bottom: 0.5em !important;
|
||||
}
|
||||
|
||||
html.dark h2 {
|
||||
color: #7099c7 !important;
|
||||
border-bottom: 2px solid #c0c0c0 !important;
|
||||
}
|
||||
|
||||
html:not(.dark) h2 {
|
||||
color: royalblue !important;
|
||||
border-bottom: 3px solid black !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* h3 */
|
||||
/***********************/
|
||||
h3 {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-style: normal !important;
|
||||
@ -94,20 +321,6 @@ h3 {
|
||||
#display: inline-block;
|
||||
}
|
||||
|
||||
html.dark h3 {
|
||||
color: lightgreen !important;
|
||||
border-bottom: 2px solid #505050 !important;
|
||||
}
|
||||
|
||||
html:not(.dark) h3
|
||||
{
|
||||
color: darkgoldenrod !important;
|
||||
border-bottom: 2px solid darkgrey !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* h4 */
|
||||
/***********************/
|
||||
h4 {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-style: normal !important;
|
||||
@ -118,43 +331,6 @@ h4 {
|
||||
display: inline-block;
|
||||
}
|
||||
|
||||
html.dark h4 {
|
||||
color: lightgreen !important;
|
||||
border-bottom: 2px solid #505050 !important;
|
||||
}
|
||||
|
||||
html:not(.dark) h4
|
||||
{
|
||||
color: darkgoldenrod !important;
|
||||
border-bottom: 2px solid darkgrey !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* p */
|
||||
/***********************/
|
||||
p {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-style: normal !important;
|
||||
font-weight: normal !important;
|
||||
font-size: 1.1rem !important;
|
||||
margin-top: 0.5em !important;
|
||||
}
|
||||
|
||||
html.dark p {
|
||||
color: #c0c0c0 !important;
|
||||
}
|
||||
|
||||
html.dark p strong {
|
||||
color: #c4c3a6;
|
||||
}
|
||||
|
||||
html:not(.dark) p {
|
||||
color: black !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* dl */
|
||||
/***********************/
|
||||
dl {
|
||||
font-family: 'Roboto Mono', monospace !important;
|
||||
font-style: normal !important;
|
||||
@ -176,366 +352,6 @@ dl dd {
|
||||
font-size: 1rem !important;
|
||||
}
|
||||
|
||||
html.dark dl,
|
||||
html.dark dl dt code,
|
||||
html.dark dl dd {
|
||||
color: #c0c0c0 !important;
|
||||
background-color: #444444 !important;
|
||||
}
|
||||
|
||||
html:not(.dark) dl,
|
||||
html:not(.dark) dl dt code,
|
||||
html:not(.dark) dl dd {
|
||||
color: black !important;
|
||||
background-color: #eeeeee !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* pre & code */
|
||||
/***********************/
|
||||
code {
|
||||
font-family: 'Roboto Mono', monospace !important;
|
||||
font-weight: normal !important;
|
||||
font-style: normal !important;
|
||||
font-size: 0.9rem !important;
|
||||
border: none !important;
|
||||
}
|
||||
|
||||
pre {
|
||||
font-family: 'Roboto Mono', monospace !important;
|
||||
font-size: 0.9rem !important;
|
||||
margin-top: 0em !important;
|
||||
margin-bottom: 0em !important;
|
||||
padding-left: 0.5em !important;
|
||||
padding-right: 0.5em !important;
|
||||
border: none !important;
|
||||
}
|
||||
|
||||
pre code {
|
||||
font-family: 'Roboto Mono', monospace !important;
|
||||
font-style: normal !important;
|
||||
font-weight: normal !important;
|
||||
font-size: 0.9rem !important;
|
||||
margin-left: 0 !important;
|
||||
border: none !important;
|
||||
}
|
||||
|
||||
html.dark code,
|
||||
html.dark pre,
|
||||
html.dark pre code {
|
||||
color: #c0c0c0 !important;
|
||||
background-color: #444444 !important;
|
||||
}
|
||||
|
||||
html:not(.dark) code,
|
||||
html:not(.dark) pre,
|
||||
html:not(.dark) pre code {
|
||||
color: black !important;
|
||||
background-color: #eeeeee !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* hr */
|
||||
/***********************/
|
||||
hr {
|
||||
height: 2px !important;
|
||||
border: none !important;
|
||||
margin-top: 1em !important;
|
||||
margin-bottom: 1em !important;
|
||||
}
|
||||
|
||||
html.dark hr {
|
||||
background-color: #505050 !important;
|
||||
}
|
||||
|
||||
html:not(.dark) hr {
|
||||
background-color: #eeeeee !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* body */
|
||||
/***********************/
|
||||
html.dark body {
|
||||
background-color: #1e1e1e !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* .hx\:font-extrabold */
|
||||
/***********************/
|
||||
html.dark .hx\:font-extrabold {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-size: 1.6rem !important;
|
||||
color: #7099c7 !important;
|
||||
}
|
||||
|
||||
html:not(.dark) .hx\:font-extrabold {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-size: 1.6rem !important;
|
||||
color: royalblue !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* .hx\:text-gray-500 */
|
||||
/* inactive */
|
||||
/***********************/
|
||||
html.dark .hx\:text-gray-500 {
|
||||
color: #c0c0c0 !important;
|
||||
}
|
||||
|
||||
html:not(.dark) .hx\:text-gray-500 {
|
||||
color: black !important;
|
||||
}
|
||||
|
||||
/*******************************/
|
||||
/* .hextra-sidebar-active-item */
|
||||
/* active */
|
||||
/*******************************/
|
||||
html.dark .hextra-sidebar-active-item {
|
||||
color: #c0c0c0 !important;
|
||||
}
|
||||
|
||||
html:not(.dark) .hextra-sidebar-active-item {
|
||||
color: black !important;
|
||||
}
|
||||
|
||||
/*************************/
|
||||
/* .content p.label-text */
|
||||
/*************************/
|
||||
html.dark .content p.label-text {
|
||||
color: salmon !important;
|
||||
}
|
||||
|
||||
html:not(.dark) .content p.label-text {
|
||||
color: darkgoldenrod !important;
|
||||
}
|
||||
|
||||
/********************************/
|
||||
/* .hextra-sidebar-item a:hover */
|
||||
/********************************/
|
||||
html.dark .hextra-sidebar-item a:hover,
|
||||
html.dark .hextra-sidebar-item a:hover span {
|
||||
background-color: rgb(250, 195, 175) !important;
|
||||
color: black !important;
|
||||
}
|
||||
|
||||
html:not(.dark) .hextra-sidebar-item a:hover,
|
||||
html:not(.dark) .hextra-sidebar-item a:hover span {
|
||||
background-color: rgb(250, 195, 175) !important;
|
||||
color: black !important;
|
||||
}
|
||||
|
||||
/*********************************/
|
||||
/* .hextra-sidebar-item */
|
||||
/* Active item default + hover */
|
||||
/* Must come AFTER regular hover */
|
||||
/*********************************/
|
||||
html.dark .hextra-sidebar-item[data-active="true"] a,
|
||||
html.dark .hextra-sidebar-item[data-active="true"] a span,
|
||||
html.dark .hextra-sidebar-item[data-active="true"] a:hover,
|
||||
html.dark .hextra-sidebar-item[data-active="true"] a:hover span {
|
||||
background-color: rgb(177, 87, 54) !important;
|
||||
color: #e0e0e0 !important;
|
||||
}
|
||||
|
||||
html:not(.dark) .hextra-sidebar-item[data-active="true"] a,
|
||||
html:not(.dark) .hextra-sidebar-item[data-active="true"] a span,
|
||||
html:not(.dark) .hextra-sidebar-item[data-active="true"] a:hover,
|
||||
html:not(.dark) .hextra-sidebar-item[data-active="true"] a:hover span {
|
||||
background-color: coral !important;
|
||||
color: white !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* main */
|
||||
/***********************/
|
||||
html.dark main {
|
||||
background-color: #252525 !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* .hx\:dark\:shadow */
|
||||
/***********************/
|
||||
html.dark .hx\:dark\:shadow-\[0_-12px_16px_\#111\] {
|
||||
box-shadow: 0 -12px 16px #1e1e1e !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* .hx\:dark\:bg-dark */
|
||||
/***********************/
|
||||
html.dark .hx\:dark\:bg-dark {
|
||||
background-color: #1e1e1e !important;
|
||||
border-color: grey !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* hextra-code-block */
|
||||
/***********************/
|
||||
.hextra-code-block {
|
||||
margin-top: 0.5rem !important;
|
||||
}
|
||||
|
||||
html.dark .hextra-code-block .highlight .chroma span.p {
|
||||
color: #c0c0c0;
|
||||
}
|
||||
|
||||
html.dark .hextra-code-block .highlight .chroma .cs,
|
||||
html.dark .hextra-code-block .highlight .chroma .cp,
|
||||
html.dark .hextra-code-block .highlight .chroma .cpf {
|
||||
font-weight: normal;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* complexity */
|
||||
/***********************/
|
||||
.complexity {
|
||||
padding: 3px 6px;
|
||||
border-radius: 0.5rem !important;
|
||||
font-weight: 600;
|
||||
font-size: 0.9rem !important;
|
||||
letter-spacing: 0.04em;
|
||||
border: 1px solid transparent;
|
||||
}
|
||||
|
||||
html.dark .complexity {
|
||||
&.constant {
|
||||
color: #7CFFB2;
|
||||
background: rgba(0,255,120,0.08);
|
||||
border-color: rgba(0,255,120,0.25);
|
||||
}
|
||||
&.logarithmic {
|
||||
color: #7CE7FF;
|
||||
background: rgba(0,200,255,0.08);
|
||||
border-color: rgba(0,200,255,0.18);
|
||||
}
|
||||
&.linear {
|
||||
color: #6AB7FF;
|
||||
background: rgba(80,140,255,0.08);
|
||||
border-color: rgba(80,140,255,0.18);
|
||||
}
|
||||
&.linearithmic {
|
||||
color: #B78CFF;
|
||||
background: rgba(140,80,255,0.08);
|
||||
border-color: rgba(140,80,255,0.18);
|
||||
}
|
||||
&.polynomial {
|
||||
color: #FFD36A;
|
||||
background: rgba(255,190,0,0.08);
|
||||
border-color: rgba(255,190,0,0.18);
|
||||
}
|
||||
&.exponential {
|
||||
color: #ff7d9c;
|
||||
background: rgba(255,0,80,0.08);
|
||||
border-color: rgba(255,0,80,0.2);
|
||||
}
|
||||
}
|
||||
|
||||
html:not(.dark) .complexity {
|
||||
&.constant {
|
||||
color: #15803D;
|
||||
background: rgba(34,197,94,0.10);
|
||||
border-color: rgba(34,197,94,0.22);
|
||||
}
|
||||
|
||||
&.logarithmic {
|
||||
color: #0E7490;
|
||||
background: rgba(6,182,212,0.10);
|
||||
border-color: rgba(6,182,212,0.22);
|
||||
}
|
||||
|
||||
&.linear {
|
||||
color: #2563EB;
|
||||
background: rgba(59,130,246,0.10);
|
||||
border-color: rgba(59,130,246,0.22);
|
||||
}
|
||||
|
||||
&.linearithmic {
|
||||
color: #7C3AED;
|
||||
background: rgba(139,92,246,0.10);
|
||||
border-color: rgba(139,92,246,0.22);
|
||||
}
|
||||
|
||||
&.polynomial {
|
||||
color: #CA8A04;
|
||||
background: rgba(234,179,8,0.12);
|
||||
border-color: rgba(234,179,8,0.24);
|
||||
}
|
||||
|
||||
&.exponential {
|
||||
color: #DC2626;
|
||||
background: rgba(239,68,68,0.10);
|
||||
border-color: rgba(239,68,68,0.22);
|
||||
}
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* font-face */
|
||||
/***********************/
|
||||
@font-face {
|
||||
font-family: Roboto;
|
||||
src: url('/fonts/roboto-v51-latin-regular.woff2') format('woff2');
|
||||
font-weight:500;
|
||||
font-style: normal;
|
||||
}
|
||||
|
||||
@font-face {
|
||||
font-family: 'Roboto Mono';
|
||||
src: url('/fonts/roboto-mono-v31-latin-500.woff2') format('woff2');
|
||||
font-weight: nornal;
|
||||
font-style: normal;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* .hx\:mb */
|
||||
/***********************/
|
||||
.hx\:mb-0 {
|
||||
display: block;
|
||||
width: 100%;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* .badges */
|
||||
/***********************/
|
||||
.badges {
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 4px;
|
||||
justify-content: flex-start;
|
||||
margin-top: 1rem;
|
||||
}
|
||||
|
||||
.badges p {
|
||||
display: contents;
|
||||
margin: 0;
|
||||
}
|
||||
|
||||
.badges div {
|
||||
width: 100%;
|
||||
display: flex;
|
||||
flex-wrap: wrap;
|
||||
gap: 4px;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* .content */
|
||||
/***********************/
|
||||
.content ul li {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-style: normal !important;
|
||||
font-weight: normal !important;
|
||||
font-size: 1.1rem !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* .err */
|
||||
/***********************/
|
||||
.err {
|
||||
background-color: transparent !important;
|
||||
color: inherit !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* ol */
|
||||
/***********************/
|
||||
ol {
|
||||
font-family: 'Roboto Mono', monospace !important;
|
||||
font-style: normal !important;
|
||||
@ -557,10 +373,51 @@ ol li code {
|
||||
font-size: 1rem !important;
|
||||
}
|
||||
|
||||
/***********************/
|
||||
/* tr */
|
||||
/***********************/
|
||||
code {
|
||||
font-family: 'Roboto Mono', monospace !important;
|
||||
font-weight: normal !important;
|
||||
font-style: normal !important;
|
||||
font-size: 0.9rem !important;
|
||||
border: none !important;
|
||||
}
|
||||
|
||||
pre code {
|
||||
font-family: 'Roboto Mono', monospace !important;
|
||||
font-style: normal !important;
|
||||
font-weight: normal !important;
|
||||
font-size: 0.9rem !important;
|
||||
margin-left: 0 !important;
|
||||
border: none !important;
|
||||
}
|
||||
|
||||
pre {
|
||||
font-family: 'Roboto Mono', monospace !important;
|
||||
font-size: 0.9rem !important;
|
||||
margin-top: 0em !important;
|
||||
margin-bottom: 0em !important;
|
||||
padding-left: 0.5em !important;
|
||||
padding-right: 0.5em !important;
|
||||
border: none !important;
|
||||
}
|
||||
|
||||
hr {
|
||||
height: 2px !important;
|
||||
border: none !important;
|
||||
margin-top: 1em !important;
|
||||
margin-bottom: 1em !important;
|
||||
}
|
||||
|
||||
p {
|
||||
font-family: Roboto, sans-serif !important;
|
||||
font-style: normal !important;
|
||||
font-weight: normal !important;
|
||||
font-size: 1.1rem !important;
|
||||
margin-top: 0.5em !important;
|
||||
}
|
||||
|
||||
tr td code{
|
||||
font-family: 'Roboto Mono', monospace !important;
|
||||
font-size: 0.8rem !important;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -1,3 +0,0 @@
|
||||
<span class="complexity {{ .Get 0 }}">
|
||||
𝐎({{ .Get 1 }})
|
||||
</span>
|
||||
@ -1,18 +0,0 @@
|
||||
{{ $email := .Get "email" | base64Encode }}
|
||||
<a class="obfuscated-email" href="#" data-email="{{ $email }}">Contact Me</a>
|
||||
|
||||
<script>
|
||||
(function() {
|
||||
// Run once when the script loads to handle clicks safely
|
||||
document.addEventListener("DOMContentLoaded", function() {
|
||||
const links = document.querySelectorAll('.obfuscated-email');
|
||||
links.forEach(link => {
|
||||
link.addEventListener('click', function(e) {
|
||||
e.preventDefault();
|
||||
const decoded = atob(this.getAttribute('data-email'));
|
||||
window.location.href = 'mailto:' + decoded;
|
||||
});
|
||||
});
|
||||
});
|
||||
})();
|
||||
</script>
|
||||
@ -3,16 +3,6 @@ if(CONFIG_ETL)
|
||||
zephyr_link_libraries(etl::etl)
|
||||
|
||||
zephyr_compile_definitions_ifdef(CONFIG_ETL_DEBUG ETL_DEBUG)
|
||||
|
||||
zephyr_compile_definitions_ifdef(CONFIG_ETL_LOG_ERRORS ETL_LOG_ERRORS)
|
||||
zephyr_compile_definitions_ifdef(CONFIG_ETL_USE_ASSERT_FUNCTION ETL_USE_ASSERT_FUNCTION)
|
||||
zephyr_compile_definitions_ifdef(CONFIG_ETL_THROW_EXCEPTIONS ETL_THROW_EXCEPTIONS)
|
||||
zephyr_compile_definitions_ifdef(CONFIG_ETL_NO_CHECKS ETL_NO_CHECKS)
|
||||
|
||||
zephyr_compile_definitions_ifdef(CONFIG_ETL_VERBOSE_ERRORS ETL_VERBOSE_ERRORS)
|
||||
zephyr_compile_definitions_ifdef(CONFIG_ETL_MINIMAL_ERRORS ETL_MINIMAL_ERRORS)
|
||||
|
||||
zephyr_compile_definitions_ifdef(CONFIG_ETL_CHECK_PUSH_POP ETL_CHECK_PUSH_POP)
|
||||
zephyr_compile_definitions_ifdef(CONFIG_ETL_CHECK_INDEX_OPERATOR ETL_CHECK_INDEX_OPERATOR)
|
||||
zephyr_compile_definitions_ifdef(CONFIG_ETL_CHECK_EXTRA ETL_CHECK_EXTRA)
|
||||
zephyr_compile_definitions_ifdef(CONFIG_ETL_LOG_ERRORS ETL_LOG_ERRORS)
|
||||
endif()
|
||||
|
||||
@ -8,78 +8,12 @@ if ETL
|
||||
|
||||
config ETL_DEBUG
|
||||
bool "Build ETL with debugging checks"
|
||||
default y if ASSERT
|
||||
|
||||
choice ETL_ERROR_MODE
|
||||
prompt "ETL error handling mode"
|
||||
help
|
||||
What ETL does when one of its checks fails.
|
||||
|
||||
config ETL_ASSERT_ERRORS
|
||||
bool "Assert in ETL_DEBUG builds, otherwise ignore"
|
||||
help
|
||||
With ETL_DEBUG, a failed check calls assert(). Without it, nothing
|
||||
is reported, but checks that guard an operation still skip it.
|
||||
With ETL_LOG_ERRORS, a failed check calls the error handler instead,
|
||||
with or without ETL_DEBUG.
|
||||
|
||||
config ETL_USE_ASSERT_FUNCTION
|
||||
bool "Call a user assert function"
|
||||
help
|
||||
A failed check calls the function registered with
|
||||
etl::set_assert_function(), and checks that guard an operation
|
||||
still skip it. Until one is registered, it calls assert(false).
|
||||
|
||||
config ETL_THROW_EXCEPTIONS
|
||||
bool "Throw an exception"
|
||||
depends on CPP_EXCEPTIONS
|
||||
help
|
||||
A failed check throws an etl::exception.
|
||||
|
||||
config ETL_NO_CHECKS
|
||||
bool "No checks"
|
||||
help
|
||||
Check conditions are not evaluated.
|
||||
|
||||
endchoice # ETL_ERROR_MODE
|
||||
|
||||
config ETL_LOG_ERRORS
|
||||
bool "Call the ETL error handler"
|
||||
depends on !ETL_USE_ASSERT_FUNCTION && !ETL_NO_CHECKS
|
||||
help
|
||||
A failed check calls the callback registered with
|
||||
etl::error_handler::set_callback(). With ETL_THROW_EXCEPTIONS it
|
||||
then throws; otherwise, checks that guard an operation still skip
|
||||
it. With no callback registered, errors are discarded.
|
||||
|
||||
choice ETL_ERROR_DETAIL
|
||||
prompt "ETL error detail level"
|
||||
help
|
||||
What information the etl::exception for a failed check carries,
|
||||
whether it is thrown or passed to the error handler or assert
|
||||
function. Unused when a failed check calls plain assert().
|
||||
|
||||
config ETL_TERSE_ERRORS
|
||||
bool "Short error code only"
|
||||
|
||||
config ETL_VERBOSE_ERRORS
|
||||
bool "Message, file and line"
|
||||
|
||||
config ETL_MINIMAL_ERRORS
|
||||
bool "Nothing"
|
||||
|
||||
endchoice # ETL_ERROR_DETAIL
|
||||
default y if DEBUG
|
||||
|
||||
config ETL_CHECK_PUSH_POP
|
||||
bool "Enable push/pop checks in ETL"
|
||||
depends on !ETL_NO_CHECKS
|
||||
|
||||
config ETL_CHECK_INDEX_OPERATOR
|
||||
bool "Enable bounds checks on ETL operator[]"
|
||||
depends on !ETL_NO_CHECKS
|
||||
|
||||
config ETL_CHECK_EXTRA
|
||||
bool "Enable extra bounds and empty checks in ETL containers"
|
||||
depends on !ETL_NO_CHECKS
|
||||
config ETL_LOG_ERRORS
|
||||
bool "Call ETL error handler instead of assert"
|
||||
|
||||
endif # ETL
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user