reveal-md

# C++11 and Beyond!

[Dvir Yitzchaki](https://github.com/dvirtz)

Note:
- The first C++ standard was published on 1998 with a small bug fix update on 2003.
- After being stale for over a decade, starting from 2011, the standard switched to a train model where a new standard is being released every 3 years.
- In this series we're going to discuss the new language and library features added to the C++ standard in the new revisions released since.
- On each session we will have one main topic and smaller features will be introduced as needed.
- Let's start.

---

## Chapters

1. [`auto`](#/1)
2. [Move Semantics](#/2)
3. [List Initialization](#/3)
4. [Variadic Templates](#/4)
5. [Lambda Expressions](#/5)
6. [Smart Pointers](#/6)
7. [`chrono`](#/7)
8. [Error Handling](#/8)
9. [Concurrency](#/9)
10. [Regular Expressions](#/10)
11. [Containers](#/11)
12. [Random](#/12)
13. [`constexpr`](#/13)
14. [C++17 Vocabulary Types](#/14)
16. [`filesystem`](#/15)

---

## Index

- [C++11](#/cpp11)
- [C++14](#/cpp14)
- [C++17](#/cpp17)
- [C++20](#/cpp20)

</div>

---

## C++11

### Language

- [x] [`auto`](#/auto) and [`decltype`](#/decltype)
- [x] [defaulted](#/defaulted) and [deleted](#/deleted) functions
- [x] [`final`](#/final) and [`override`](#/override)
- [x] [trailing return type](#/trailing_return)
- [x] [rvalue references](#/rvalue_references)
- [x] [move constructors](#/move_constructors) and [move assignment operators](#/move_constructors)
- [x] [scoped enums](#/scoped_enums)
- [x] [`constexpr`](#/constexpr) and [literal types](#/literal_type)
- [x] [list initialization](#/list_initialization)
- [x] [delegating](#/delegating_constructors) and inherited constructors
- [ ] brace-or-equal initializers
- [x] [`nullptr`](#/nullptr)
- [ ] `long long`
- [x] [`char16_t` and `char32_t`](#/utf_chars)
- [x] [type aliases](#type_aliases)
- [x] [variadic templates](#/variadic_templates)
- [ ] generalized (non-trivial) unions
- [ ] generalized PODs (trivial types and standard-layout types)
- [x] [Unicode string literals](#/utf_chars)
- [x] [user-defined literals](#/UDL)
- [x] [attributes](#/attributes)
- [x] [lambda expressions](#/lambda_expressions)
- [x] [`noexcept` specifier](#/noexcept_specifier) and [`noexcept` operator](#/noexcept_operator)
- [ ] `alignof` and `alignas`
- [x] multithreaded [memory model](#/atomic)
- [x] [thread-local](#/thread_local) storage
- [ ] GC interface
- [x] [range based for loop](#/range_for)
- [x] [`static_assert`](#/static_assert)

### Library

- [x] [atomic](#/atomic) operations library
- [x] [`emplace()`](#/emplace)
- [x] [`std::unique_ptr`](#/unique_ptr), [`std::shared_ptr`](#/shared_ptr), [`std::weak_ptr`](#/weak_ptr)
- [ ] `std::move_iterator`
- [x] [`std::initializer_list`](#/initializer_list)
- [ ] stateful and scoped allocators
- [x] [`std::forward_list`](#/forward_list)
- [x] [`chrono`](#/chrono) library
- [x] [`ratio`](#/ratio) library
- [ ] new algorithms
- [ ] Unicode conversion facets
- [x] [`thread`](#/concurrency) library
- [x] [`std::exception_ptr`](#/exception_ptr)
- [x] [`std::error_code`](#/error_code) and [`std::error_condition`](#/error_condition)
- [x] iterator improvements
  - [x] [`std::begin`/`end`](#/begin_end)
  - [x] [`std::next`/`prev`](#/next_prev)
- [ ] Unicode conversion functions
- [x] [`std::array`](#/array)
- [x] [`std::tuple`](#/tuple)

</div>

---

## C++14

### Language

- [x] variable templates(#/variable_templates)
- [x] [generic lambdas](#/generic_lambdas)
- [x] [lambda init-capture](#/lambda_init_capture)
- [ ] `new`/`delete` elision
- [x] [relaxed](#/relaxed_constexpr) restrictions on `constexpr` functions
- [x] [binary literals](#/binary_literals)
- [x] [digit separators](#/binary_literals)
- [x] [return type deduction](#/auto_return) for functions
- [ ] aggregate classes with default non-static member initializers.

### Library

- [x] [`std::make_unique`](#/make_unique)
- [x] `std::shared_timed_mutex` and [`std::shared_lock`](#/shared_lock)
- [ ] `std::integer_sequence`
- [ ] `std::exchange`
- [ ] `std::quoted`
- [ ] two-range overloads for some algorithms
- [ ] type alias versions of type traits
- [x] user-defined literals for [`basic_string`](#/string_literals), [`duration`](#/duration_literals) and [`complex`](#/complex_literals)

</div>

---

## C++17

### Language

- [x] [fold-expressions](#/fold_expressions)
- [x] [class template argument deduction](#/ctad)
- [ ] non-type template parameters declared with auto
- [x] compile-time [`if constexpr`](#/constexpr_if)
- [ ] inline variables
- [ ] structured bindings
- [ ] initializers for if and switch
- [ ] u8 character literal
- [ ] simplified nested namespaces
- [ ] using-declaration declaring multiple names
- [ ] made `noexcept` part of type system
- [ ] new order of evaluation rules
- [ ] guaranteed copy elision
- [ ] lambda capture of `*this`
- [x] [`constexpr` lambda](#/constexpr_lambda)
- [ ] attribute namespaces don't have to repeat
- [ ] new attributes:
  - [ ] `[[fallthrough]]`
  - [ ] `[[nodiscard]]`
  - [ ] `[[maybe_unused]]`
- [ ] __has_include

</div>

---

## C++17

### Library

- [ ] `tuple`:
  - [ ] `apply`
  - [ ] deduction guides
  - [ ] `make_from_tuple`
- [x] [`variant`](#/variant)
- [ ] `launder`
- [ ] `to_chars`/`from_chars`
- [ ] `as_const`
- [ ] searchers
- [x] [`optional`](#/optional)
- [x] [`any`](#/any)
- [ ] `not_fn`
- [ ] uninitialized memory
  - [ ] `destroy_at`
  - [ ] `destroy`
  - [ ] `destroy_n`
  - [ ] `uninitialized_move`
  - [ ] `uninitialized_value_construct`
- [ ] `weak_from_this`
- [ ] polymorphic allocators
- [ ] `aligned_alloc`
- [ ] transparent `owner_less`
- [ ] array support for `shared_ptr`
- [ ] allocation functions with explicit alignment
- [ ] `byte`
- [ ] [`conjunction`](#/conjunction)/`disjunction`/`negation`
- [x] type trait [variable templates](#/variable_templates) (xxx_v)
- [ ] `is_swappable`
- [ ] `is_invocable`
- [ ] `is_aggregate`
- [ ] `has_unique_object_representations`
- [ ] `clamp`
- [ ] execution policies
- [ ] `reduce`
- [ ] `inclusive_scan`
- [ ] `exclusive_scan`
- [ ] `map`/`set` extract and merge
- [ ] `map`/`unordered_map` `try_emplace` and `insert_or_assign`
- [ ] contiguous iterators
- [ ] non-member `size`/`empty`/`data`
- [ ] mathematical special functions
- [ ] `gcd`
- [ ] `lcm`
- [ ] 3D `hypot`
- [x] [`is_always_lock_free`](#/is_always_lock_free)
- [x] variadic [`lock_guard`](#/scoped_lock)
- [ ] cache line interface
- [ ] `uncaught_exceptions`
- [ ] `timespec_get`
- [x] [rounding functions](#/chrono_rounding) for `duration` and `time_point`

</div>

---

## C++20

### Language

- [ ] Feature test macros
- [ ] 3-way comparison `operator<=>` and `operator==() = default`
- [ ] designated initializers
- [ ] init-statements and initializers in range-for
- [x] [char8_t](#/utf_chars)
- [ ] new attributes
  - [ ] `[[no_unique_address]]`
  - [ ] `[[likely]]`
  - [ ] `[[unlikely]]`
- [ ] pack-expansions in lambda captures
- [ ] removed the requirement to use `typename` to disambiguate types in many contexts
- [x] [`consteval`](#/consteval), [`constinit`](#/constinit)
- [x] further relaxed [`constexpr`](#/20_constexpr)
- [ ] signed integers are 2's complement
- [ ] aggregate initialization using parentheses
- [ ] Coroutines
- [ ] Modules
- [ ] Constraints and concepts
- [ ] Abbreviated function templates
- [ ] DR: array new can deduce array size

</div>

---

## C++20

### Library

- [ ] Formatting library
- [ ] Calendar and Time Zone library
- [ ] `std::source_location`
- [ ] `std::span`
- [ ] `std::endian`
- [ ] array support for `std::make_shared`
- [ ] `std::remove_cvref`
- [ ] `std::to_address`
- [ ] floating point and `shared_ptr` atomics
- [ ] `std::barrier`, `std::latch`, and `std::counting_semaphore`
- [ ] `std::jthread` and thread cancellation classes
- [ ] `<version>`
- [ ] `std::osyncstream`
- [ ] `std::u8string` and other `char8_t` uses
- [x] [`constexpr` for `<algorithm>`, `<utility>`, `<complex>`](#/20_constexpr_lib/0)
- [ ] `std::string::starts_with` / `ends_with` and `std::string_view::starts_with` / `ends_with`
- [ ] `std::assume_aligned`
- [ ] `std::bind_front`
- [ ] `std::c8rtomb`/`std::mbrtoc8`
- [ ] `std::make_obj_using_allocator` etc
- [ ] `std::make_shared_for_overwrite` / `std::make_unique_for_overwrite`
- [ ] heterogeneous lookup in unordered associative containers
- [ ] `std::polymoprhic_allocator` with additional member functions and `std::byte` as its default template argument
- [ ] `std::execution::unseq`
- [ ] `std::midpoint` and `std::lerp`
- [ ] `std::ssize`
- [ ] `std::is_bounded_array`, `std::is_unbounded_array`
- [ ] Ranges
- [ ] uniform container erasure (`std::erase`/`std::erase_if`)
- [ ] Mathematical constants

</div>

----

---

## What problems can you find in this code?

```cpp
///fails=conversion from 'int' to non-scalar type 'std::vector<int>' requested
///hide
#include <string>
#include <vector>

void foo() {
///unhide
// (a)
int i;

// (b)
std::vector<std::string> v;
int size = v.size();

// (c)
std::vector<int> v1(5);
std::vector<int> v2 = 5;
///hide
}
```

Note:
- uninitialized variable
- possible data lose converting from `size_t` to `int`
- although looking similar, the second line does not compile, because the constructor is *explicit*

---

## And this?

```cpp
///fails=conversion from '__normal_iterator<const int*,[...]>' to non-scalar type '__normal_iterator<int*,[...]>' requested
///hide
#include <vector>
///unhide
void traverser( const std::vector<int>& v ) {
  for( std::vector<int>::iterator i = v.begin(); 
       i != v.end(); 
       ++i )
  {
        // ...
  }
}
```

Note:
- this code does not compile because we need a `const_iterator`

---

## And this?

```cpp
///hide
#include <iostream>

struct gadget{
    gadget() { std::cout << "gadget()\n"; }
    gadget(const gadget&) { std::cout << "gadget(gadget&)\n"; }
};

struct widget{
    widget() { std::cout << "widget()\n"; }
    widget(const gadget&) { std::cout << "widget(gadget&)\n"; }
};
///unhide
gadget get_gadget();
///hide
gadget get_gadget() {
    return gadget();
}

int main() {
///unhide
widget w = get_gadget();
///hide
}
```

<small> assuming `gadget` is implicitly convertible to `widget` </small>

Note:
- a temporary `getget` is created which might be a performance pitfall, as the creation of the temporary object is not at all obvious from reading the call site alone.
- it's possible that using `gadget` is just as well as viable in this code

---

## Non member `begin` and `end`

Accept anything with a member `begin` and `end` as well as C-style arrays

```cpp
///hide
#include <vector>
#include <cassert>
 
int main() 
{
///unhide
std::vector<int> v = { 3, 1, 4 };
auto vi = std::begin(v);
assert(*vi == 3);

int a[] = { -5, 10, 15 };
auto ai = std::begin(a);
assert(*ai == -5);
///hide
}
```

Note:
- prefer to use this in generic code

---

What does this function do?

```cpp
///hide
#include <algorithm>
#include <cassert>

using namespace std;
///unhide
template<class Container, class Value>
void some_function( Container& c, const Value& v ) {
    if( find(begin(c), end(c), v) == end(c) )
        c.push_back(v); 
    assert( !c.empty() );
}
```

Note:
- `append_unique`

---

# auto

Slides are based on [Herb Sutter's](https://herbsutter.com) GOTW series

</div>

Note: 
- our main topic today
- oldest feature in C++11 (first implementation at 1983)

---

## declaring a local variable

syntax

```cpp
///hide
void foo(int its_initial_value){
///unhide
auto my_new_variable = its_initial_value;
///hide
}
```

deduce type from initializing expression

```cpp
///hide
void foo(int its_initial_value){
///unhide
auto x = 0x12345678ULL; // type of x is unsigned long long
///hide
}
```

---

## similar to template type deduction
```cpp
template<class T> void f( T ) { }

///hide
int main() {
///unhide
int val = 0;

f( val );     // deduces T == int, calls f<int>( val )

auto x = val; // deduces T == int, x is of type int
///hide
}
```

---

## Strips off qualifiers and references
```cpp
///hide
int main() {
///unhide
int           val = 0;

int&          ir  = val;
auto          e   = ir;   // The type of e is int

const int     ci  = val;
auto          h   = ci;   // The type of h is int

const int*    cip = &val;
auto          i   = cip;  // The type of i is const int*

int* const    ipc = &val;
auto          j   = ipc;  // The type of j is int*
///hide
}
```

Note: You want your new variable to be just like some existing variable or expression over there, and be initialized from it, but that only means that you want the same basic type, not necessarily that other variable’s own personal secondary attributes such as top-level const– or volatile-ness and &/&& reference-ness which are per-variable. For example, just because he’s const doesn’t mean you’re const, and vice versa.

---

## Can be qualified

```cpp
///hide
int main() {
///unhide
int         val = 0;
auto        a   = val; // The type of a is int
auto&       b   = val; // The type of b is int&
const auto  c   = val; // The type of c is const int
const auto& d   = val; // The type of d is const int&
///hide
}
```

Note: If needed, `const` and `&` can be explicitly added

---

---

## Forces initialization

instead of

```cpp
///hide
int main() {
///unhide
int i;
///hide
}
```

write

```cpp
///hide
int main() {
///unhide
auto i = 42;    // guaranteed to be initialized
///hide
}
```

Note: solving the first problem

---

## Avoid narrowing conversions

instead of

```cpp
///hide
#include <string>
#include <vector>

int main() {
///unhide
std::vector<std::string> v;
int size = v.size();
///hide
}
```

write

```cpp
///hide
#include <string>
#include <vector>

int main() {
std::vector<std::string> v;
///unhide
auto size = v.size(); // exact type, no narrowing
///hide
}
```

Note: solving narrowing conversions

---

## DRY initialization syntax

instead of

```cpp
///hide
#include <vector>

int main() {
///unhide
std::vector<int> v2 = std::vector<int>(5);
///hide
}
```

write

```cpp
///hide
#include <vector>

int main() {
///unhide
auto v2 = std::vector<int>(5); // keep it DRY
///hide
}
```

Note: if one wants to use explicit constructor with the assignment syntax they would have to repeat the type but not with auto

---

## Correct type by default

instead of

```cpp
///hide
#include <vector>

void foo(std::vector<int> &v) {
///unhide
std::vector<int>::const_iterator i = v.begin();
///hide
}
```

write

```cpp
///hide
#include <vector>

void foo(std::vector<int> &v) {
///unhide
auto i = begin(v);
///hide
}
```

Note: 
- correct and clear and simpler
- stays correct if we change the type of the parameter to be non-const
- or even replace vector with some other type of container

---

## Avoids hidden temporaries

instead of

```cpp
///hide
#include <iostream>

struct gadget{
    gadget() { std::cout << "gadget()\n"; }
    gadget(const gadget&) { std::cout << "gadget(gadget&)\n"; }
};

struct widget{
    widget() { std::cout << "widget()\n"; }
    widget(const gadget&) { std::cout << "widget(gadget&)\n"; }
};

gadget get_gadget() {
    return gadget();
}

int main() {
///unhide
widget w = get_gadget();
///hide
}
```

write

```cpp
///hide
#include <iostream>

struct gadget{
    gadget() { std::cout << "gadget()\n"; }
    gadget(const gadget&) { std::cout << "gadget(gadget&)\n"; }
};

struct widget{
    widget() { std::cout << "widget()\n"; }
    widget(const gadget&) { std::cout << "widget(gadget&)\n"; }
};

gadget get_gadget() {
    return gadget();
}

int main() {
///unhide
auto w = get_gadget(); // gadget can be used
///hide
}
```

```cpp
///hide
#include <iostream>

struct gadget{
    gadget() { std::cout << "gadget()\n"; }
    gadget(const gadget&) { std::cout << "gadget(gadget&)\n"; }
};

struct widget{
    widget() { std::cout << "widget()\n"; }
    widget(const gadget&) { std::cout << "widget(gadget&)\n"; }
};

gadget get_gadget() {
    return gadget();
}

int main() {
///unhide
auto w = widget(get_gadget()); // widget is needed
///hide
}
```

---

## `static_assert`

Check assertions at compile time:
```cpp
///hide
constexpr auto bool_constexpr = true;
#define message "should never appear"
///unhide
static_assert ( bool_constexpr , message );
```

For example:
```cpp
static_assert(sizeof(void *) == 8, 
  "Only 64-bit code generation is supported.");
```

Note:
- If you only support 64 bit you can give a compile time error if anyone tries to use you code to compile for other architectures
- Open CE

---

## `decltype`

Similar to `sizeof(expr)` but returns type instead of size.

```cpp
#include <type_traits>

int f();

static_assert(sizeof(f()) == sizeof(int), 
  "f should return int");
static_assert(std::is_same<int, decltype(f())>::value, 
  "f should return int");
```

---

## what should be the return type

```cpp
///hide
#include <iostream>
#define RETURN_TYPE auto

///unhide
template <typename Func, typename T>
RETURN_TYPE trace(Func f, T t) { 
  std::cout << "Calling f on " << t;
  return f(t); 
}
```

Note: we implement a generic tracing function which gets a function `f` and a value `t` and returns the result of `f(t)`.

---

## what should be the return type

first try

```cpp
///fails='t' was not declared in this scope
///hide
#include <iostream>

///unhide
template <typename Func, typename T>
decltype(f(t)) trace(Func f, T t) { 
  std::cout << "Calling f on " << t;
  return f(t); 
}
```

Note: 
- open CE
- to express the return type we need to refer to `f` and `t` which are unknown to the compiler at the point of defining the return type.

---

## trailing return type

```cpp
///hide
#include<iostream>
///unhide
template <typename Func, typename T>
auto trace(Func f, T t) -> decltype(f(t)) { 
  std::cout << "Calling f on " << t;
  return f(t); 
}
```

Note: we replace the return type with `auto` and add the actual return type after the arrow.
At this point we can refer to `f` and `t`.

---

## `auto` return type (C++14)

```cpp
///hide
#include<iostream>
///unhide
template <typename Func, typename T>
auto trace(Func f, T t) { 
  std::cout << "Calling f on " << t;
  return f(t); 
}
```

Note: in c++14, this idiom was shortened to mean deduce the return type from the return statement

---

# CONCERNED?

Note:
- There are number of popular concerns about using auto.
- Let's tackle some of them.

---

> writing auto to declare a variable is primarily about saving typing.

---

Writing auto is about

- [x] correctness 
- [x] performance 
- [x] maintainability 
- [x] robustness 
- [x] convenience

Note:
No, writing auto is about
- correctness
- performance
- maintainability
- robustness
- AND FINALLY, ALSO
- convenience

Next...

---

> But in some cases I do want to commit to a specific type, not automatically deduce it, so I can’t use auto.

---

Use

```cpp
///hide
template<typename type>
void foo(type init) {
///unhide
auto x = type(init);
///hide
}
```

Note: WRONG!

---

> My code gets unreadable quickly when I don’t know what exact type my variable is without hunting around to see what that function or expression returns, so I can’t just use auto all the time.

---

How many concrete types are in this function?

```cpp
///hide
#include <algorithm>
#include <cassert>

using namespace std;
///unhide
template<class Container, class Value>
void append_unique( Container& c, const Value& v ) {
    if( find(begin(c), end(c), v) == end(c) )
        c.push_back(v); 
    assert( !c.empty() );
}
```

Note: 
the lack of exact types makes it much more powerful and doesn’t significantly harm its readability

---

## write code against interfaces, not implementations

-   Functions - hiding code
-   OO - hiding code and data
-  Polymorphism - hiding type

Note: 
- we write functions to hide implementation code
- we write class to hide private members and methods
- we use static (templates) and dynamic (virtual methods) polymorphism to write generic code
- using `auto` is another link in this software development chain

---

## Using `auto`

-  guarantees the variable will be initialized
-  efficient by default
-  guarantees that you will use the correct exact type
-  guarantees that you will continue to use the correct exact type
-  is the only good option for hard-to-spell and impossible-to-spell types
-  is just generally simpler and less typing

---

# Thank you

----

---

## How many copies?

```cpp
///hide
#include <vector>
#include <cstdint>

///unhide
template<typename Buffer>
std::vector<Buffer> generateBuffers(const size_t INSTANCES, 
                                    const size_t BUFFER_SIZE)
{
    std::vector<Buffer> v;
    for (size_t i = 0; i < INSTANCES; ++i)
    {
        v.push_back(Buffer(BUFFER_SIZE));
    }
    return v;
}
```

Note:
- copying from temporary buffer
- copying when capacity is full
- possible copying when returning `v`
- in all theses cases the source is destroyed immediately after copying

---

## Member initialization

```cpp [|4-6|6]
///hide
#include <string>
struct HashingFunction{
    HashingFunction(const std::string&);
};
struct D {};
int f(D);
///unhide
class A
{
public:
    A() : a(7), b(5), hash_algorithm("MD5"), s("Constructor run") {}
    A(int a_val) : a(a_val), b(5), hash_algorithm("MD5"), s("Constructor run") {}
    A(D d) : a(f(d)), b(a), hash_algorithm("MD5"), s("Constroctor run") {}
private:
    int a, b;
    HashingFunction hash_algorithm;
    std::string s;
};
```

---

## Non-static data member initializers

```cpp [|8-10|4-6]
///hide
#include <string>
struct HashingFunction{
    HashingFunction(const std::string&);
};
struct D {};
int f(D);
///unhide
class A
{
public:
    A() {}
    A(int a_val) : a(a_val) {}
    A(D d) : a(f(d)), b(a) {}
private:
    int a = 7, b = 5;
    HashingFunction hash_algorithm = HashingFunction("MD5");
    std::string s = "Constructor run";
};
```

Note: `auto` is not allowed even with initializer;

---

## Delegating constructors

```cpp [|4-9|10]
///hide
#include <string>
struct HashingFunction{
    HashingFunction(const std::string&);
};
struct D {};
int f(D);
///unhide
class A
{
public:
    A(int _a = 7, 
      int _b = 5, 
      const HashingFunction& _hash_algorithm = HashingFunction("MD5"), 
      const std::string& _s = "Constructor run") 
    : a(_a), b(_b), hash_algorithm(_hash_algorithm), s(_s) 
    {}
    A(D d) : A(f(d), a) {}
private:
    int a, b;
    HashingFunction hash_algorithm;
    std::string s;
};
```

---

## `nullptr`

A type safe replacement for `NULL` macro

```cpp
///external
///compiler=vcpp_v19_24_x64
///options=/O2
///hide
#include <cstddef>
///unhide
void foo(int);
void foo(char*);

///hide
void call(){
///unhide
foo(42); // calls foo(int);
foo(NULL); // calls foo(int);
foo(nullptr); // calls foo(char*);
///hide
}
```

---

## Buffer copy

```cpp [|2-3|5-10|12-18|20-29|31]
///hide
#include <algorithm>
///unhide
struct Buffer {
    size_t m_size;
    int* m_pArray;

Buffer(size_t size = 0) 
        : m_size(size)
        , m_pArray(size == 0 
                    ? nullptr 
                    : new int[size])
    {}

Buffer(const Buffer& other) 
        : Buffer(other.m_size)
    {
        std::copy(other.m_pArray, 
                  other.m_pArray + m_size, 
                  m_pArray);
    }

Buffer& operator=(const Buffer& other) 
    {
        delete[] m_pArray;
        m_size = other.m_size;
        m_pArray = new int[m_size];
        std::copy(other.m_pArray, 
                  other.m_pArray + m_size, 
                  m_pArray);
        return *this;
    }

~Buffer() { delete[] m_pArray; }
};

```

---

## implement assignment by copy constructor

```cpp [20-26]
///hide
#include <algorithm>
///unhide
struct Buffer {
    size_t m_size;
    int* m_pArray;

Buffer(size_t size = 0) 
        : m_size(size)
        , m_pArray(size == 0 
                    ? nullptr 
                    : new int[size])
    {}

Buffer(const Buffer& other) 
        : Buffer(other.m_size)
    {
        std::copy(other.m_pArray, 
                  other.m_pArray + m_size, 
                  m_pArray);
    }
    
    Buffer& operator=(const Buffer& other) 
    {
        Buffer tmp(other);
        std::swap(m_size, tmp.m_size);
        std::swap(m_pArray, tmp.m_pArray);
        return *this;
    }

~Buffer() { delete[] m_pArray; }
};

```

---

## Steal from temporary

```cpp
///hide
#include <cstddef>
struct Buffer {
size_t m_size;
int* m_pArray;

Buffer(size_t size = 0) 
    : m_size(size)
    , m_pArray(size == 0 
                ? nullptr 
                : new int[size])
{}
///unhide
Buffer(const Buffer& temporary)
    : m_size(temporary.m_size)
    , m_pArray(temporary.m_pArray)
{}
///hide
~Buffer() { delete[] m_pArray; }
};
```

Note: 
- As we know the temporary won’t be used after the assignment operator, why not “move” its resources to the new object instead of copy them?
- There's a problem with this code though - double delete

---

## Without double delete

```cpp
///hide
#include <cstddef>
struct Buffer {
size_t m_size;
int* m_pArray;

Buffer(size_t size = 0) 
    : m_size(size)
    , m_pArray(size == 0 
                ? nullptr 
                : new int[size])
{}
///unhide
Buffer(Buffer& temporary)
    : m_size(temporary.m_size)
    , m_pArray(temporary.m_pArray)
{
    temporary.m_size = 0;
    temporary.m_pArray = nullptr;
}
///hide
~Buffer() { delete[] m_pArray; }
};
```

---

# Move semantics

---

## How can we tell?

```cpp
///hide
#include <algorithm>

struct Buffer {
    size_t m_size;
    int* m_pArray;

Buffer(size_t size = 0) 
        : m_size(size)
        , m_pArray(size == 0 
                    ? nullptr 
                    : new int[size])
    {}
    Buffer(const Buffer& other)
        : Buffer(other.m_size)
    {
        std::copy(other.m_pArray, 
                    other.m_pArray + m_size, 
                    m_pArray);
    }
    ~Buffer() { delete[] m_pArray; }
};

int main() {
const auto BUFFER_SIZE = 4;
///unhide
Buffer c = Buffer(BUFFER_SIZE); // can move
Buffer d = c; // cannot move
// keep using c and d
///hide
}
```

Note:
We need a way to distinguish between references to temporary objects and regular objects.

---

## Value type

Originally:

> - l-value: can be on the left hand side of an assignment
> - r-value: can be **only** on the right hand side of an assignment

---

## Left or right?

```cpp [|4|5|6|7|8|9]
///hide
#include <vector>
#include <algorithm>

using std::min;

int main() {
///unhide
int a, b, *p;
std::vector<int> v(2);

a         = 42;
b         = a;
b         = a * b;
p         = new int;
*p        = min(a, b);
v.front() = 6;
///hide
}
```

---

## Value type

More accurately:

> an expression is an *l*-value if it has a specific memory location and its address can be taken using the & operator, otherwise it is an *r*-value.

---

## Value type

```cpp
///fails=lvalue required as unary '&' operand
///hide
void foo() {
///unhide
int a, b;
int* c;
c = &a;
c = &(a * b); // error
///hide
}
```

All expressions returning temporary values are r-values.

All named objects are l-values.

---

## L-value references

A (non-const) reference can be bound only to l-values:

```cpp
///fails=cannot bind non-const lvalue reference of type 'int&' to an rvalue of type 'int'
int a, b;
int& c = a;
int& d = (a * b); // error
```

---

## R-value references

Can be bound only to r-values and uses the && syntax.

```cpp
///fails=cannot bind rvalue reference of type 'int&&' to lvalue of type 'int'
int a = 1, b = 2;
int&& c = a; // error
int&& d = (a * b);
cout << ++d << endl;
```

Note: `d` is extending the lifetime of `(a * b)`

---

## Move constructor and assignment operator

```cpp [|3-11,22-24|13-20|26-33]
///hide
#include <cstddef>
#include <utility>

///unhide
struct MovableBuffer
{
    size_t m_size;
    int* m_pArray;

MovableBuffer(size_t size = 0);

~MovableBuffer() { delete[] m_pArray; }

// copy constructor
    MovableBuffer(const MovableBuffer& other);

// move constructor
    MovableBuffer(MovableBuffer&& other)
        : m_size(other.m_size)
        , m_pArray(other.m_pArray)
    {
        other.m_size = 0;
        other.m_pArray = nullptr;
    }

// copy assignment operator
    MovableBuffer& operator=(
        const MovableBuffer& other);

// move assignment operator
    MovableBuffer& operator=(MovableBuffer&& other)
    {
        MovableBuffer tmp(other);
        std::swap(m_size, tmp.m_size);
        std::swap(m_pArray, tmp.m_pArray);
        return *this;
    }
};

```

---

# [Let's benchmark](http://quick-bench.com/ryKzdF90wADpRQ6hHuvUvhat1Z0)

---

## Move only

```cpp [|20]
///fails=use of deleted function 'constexpr MoveOnlyBuffer::MoveOnlyBuffer(const MoveOnlyBuffer&)'
///hide
#include <cstddef>
#include <utility>

///unhide
struct MoveOnlyBuffer
{
    size_t m_size;
    int* m_pArray;

MoveOnlyBuffer(size_t size = 0);

~MoveOnlyBuffer() { delete[] m_pArray; }
    
    MoveOnlyBuffer(MoveOnlyBuffer&& other) 
        : m_size(other.m_size)
        , m_pArray(other.m_pArray)
    {
        other.m_size = 0;
        other.m_pArray = nullptr;
    }

MoveOnlyBuffer& operator=(MoveOnlyBuffer&& other)
    {
        MoveOnlyBuffer tmp(other);
        std::swap(m_size, tmp.m_size);
        std::swap(m_pArray, tmp.m_pArray);
        return *this;
    }
};

```

Note: 
- show compiler error
- performance bug in the movable class

---

## `std::move`

casts the argument to an `rvalue`

```cpp
///hide
#include <type_traits>
///unhide
namespace std {

template< class T >
typename remove_reference<T>::type&& move( T&& t ) noexcept {
    return static_cast<typename remove_reference<T>::type&&>(t);
}

} // namespace std
```

---

## (really) move only

```cpp [20]
///hide
#include <cstddef>
#include <utility>

///unhide
struct MoveOnlyBuffer
{
    size_t m_size;
    int* m_pArray;

MoveOnlyBuffer(size_t size = 0);

MoveOnlyBuffer& operator=(MoveOnlyBuffer&& other)
    {
        MoveOnlyBuffer tmp(std::move(other));
        std::swap(m_size, tmp.m_size);
        std::swap(m_pArray, tmp.m_pArray);
        return *this;
    }
};

```

---

# [Let's benchmark](http://quick-bench.com/mevho4kNsJTPbnA7S8zrFToi5Is)

---

## Exception safety

<table style="font-size:0.55em">
    <tr>
        <td>No-throw exception guarantee</td> <td>the function never throws exceptions</td>
    </tr>
    <tr>
        <td>Strong exception guarantee</td> <td>If the function throws an exception, the state of the program is rolled back to the state just before the function call</td>
    </tr>
    <tr>
        <td>Basic exception guarantee</td> <td>If the function throws an exception, the program is in a valid state. No resources are leaked, and all objects' invariants are intact</td>
    </tr>
    <tr>
        <td>No exception guarantee</td> <td><img src="02_move/dragons.jpg" alt="dragons" style="position: relative; height: 20%; left: 30%"></img></td>
    </tr>
</table>

---

`vector::push_back` pseudo code

```cpp
///fails=expected initializer before '<' token
template<typename T>
void vector<T>::push_back(const T& value) {
    if (size == capacity) {
        allocate larger buffer
        if (is movable) {
            // move all Ts to the new buffer
        } else {
            // copy all Ts to the new buffer
        }
    }
    // copy value to the end if the buffer
}
```

---

## copy

---

## move

---

## `noexcept` specifier

A function can be decorated with `noexcept(expr)` specifier to indicate whether it will throw:

```cpp
int* allocate_array_impl(int N){
    return new int[N];
}

template<int N>
int* allocate_array() noexcept(N >= 0) {
    return allocate_array_impl(N);
}

int* a = allocate_array<42>();
int* b = allocate_array<-1>();
```

`noexcept` is a shortcut for `noexcept(true)`.

---

## `noexcept` operator

`noexcept(expr)` returns `true` if `expr` is declared to not throw any exceptions.

```cpp
template<typename Func>
void wrapper(Func func) noexcept(noexcept(func())) {
    func();
}
```

---

- destructors are implicitly `noexcept`
- if a `noexcept` function throws, the function `std::terminate` is called

```cpp
extern void f();  // potentially-throwing
void g() noexcept {
    f();      // valid, even if f throws
    throw 42; // valid, effectively a call to std::terminate
}
```

---

## `noexcept` move

```cpp [14, 27-28]
///hide
#include <cstddef>
#include <utility>

///unhide
struct MovableBuffer
{
    size_t m_size;
    int* m_pArray;

MovableBuffer(size_t size = 0);

~MovableBuffer() { delete[] m_pArray; }

// copy constructor
    MovableBuffer(const MovableBuffer& other);

// move constructor
    MovableBuffer(MovableBuffer&& other) noexcept
        : m_size(other.m_size)
        , m_pArray(other.m_pArray)
    {
        other.m_size = 0;
        other.m_pArray = nullptr;
    }

// copy assignment operator
    MovableBuffer& operator=(
        const MovableBuffer& other);

// move assignment operator
    MovableBuffer& operator=(
        MovableBuffer&& other) noexcept
    {
        MovableBuffer tmp(std::move(other));
        std::swap(m_size, tmp.m_size);
        std::swap(m_pArray, tmp.m_pArray);
        return *this;
    }
};

```

---

# [Let's benchmark](http://quick-bench.com/Po3o1F2MuAsyRNciCaOoAcnQbyY)

---

## `std::move` again

```cpp
///hide
#include <type_traits>
///unhide
template< class T >
typename std::remove_reference<T>::type&& move( T&& t ) noexcept {
    return static_cast<typename std::remove_reference<T>::type&&>(t);
}
```

We can also move `lvalue`s that are not needed anymore:

```cpp
///hide
#include <string>
#include <vector>
#include <iostream>

void foo() {
///unhide
std::vector<std::string> inputs;
for (std::string s; std::cin >> s;) {
    inputs.push_back(std::move(s));
}
///hide
}
```

Note: But `s` is an `lvalue`!!

---

## reference collapsing

```cpp
///hide
#include <type_traits>

///unhide
template<typename T>
using lref = T&;

template<typename T>
using rref = T&&;

static_assert(std::is_same<lref<lref<int>>, int&>::value, 
              "& * & = &");
static_assert(std::is_same<lref<rref<int>>, int&>::value, 
              "& * && = &");
static_assert(std::is_same<rref<lref<int>>, int&>::value, 
              "&& * & = &");
static_assert(std::is_same<rref<rref<int>>, int&&>::value, 
              "&& * && = &&");
```

---

## forwarding ref

calling `std::move(s)` instantiates

```cpp
///fails='move' in namespace 'std' does not name a template type
std::move<std::string&>(std::string & && t)
```

i.e.

```cpp
///fails='move' in namespace 'std' does not name a template type
std::move<std::string&>(std::string & t)
```

- `template<typename T>(T&&)` just retains the type of the call site argument
- such a reference is called a **forwarding reference**

---

## `std::forward`

forwards the argument to another function with the value category it had when passed to the calling function.

```cpp
///hide
#include<iostream>
///unhide
template <typename Func, typename T>
auto trace(Func&& f, T&& t) { 
  std::cout << "Calling f on " << t;
  return f(std::forward<T>(t)); 
}
```

---

## Special member functions

| | | |
|-|-|-|
|1.|default constructor|`T()`|
|2.|copy constructor|`T(const T&)`|
|3.|move constructor|`T(T&&)`|
|4.|destructor|`~T()`|
|5.|copy assignment|`T& operator=(const T&)`|
|6.|move assignment|`T& operator=(T&&)`|

**Special** - compiler generated, under certain circumstances

---

![special members](02_move/special_members.jpg)

Source: [Howard Hinnant](https://howardhinnant.github.io/classdecl.html)

---

## deleted function

e.g. to prevent narrowing conversions:

```cpp
///fails=use of deleted function 'void foo(int)'
void foo(short i);
void foo(int i) = delete;

///hide
void bar() {
///unhide
foo(static_cast<short>(42));    // ok
foo(42);                        // error, deleted function
///hide
}
```

---

## defaulted special member function

can force the compiler to generate

```cpp
///hide
#include <type_traits>

///unhide
struct T {
    T() = default;
    T(int i);

T(T&&);
    T(const T&) = default;
};

static_assert(std::is_default_constructible<T>::value, 
              "default");
static_assert(std::is_copy_constructible<T>::value, 
              "copy");
```

---

## rule of 0

> If you can avoid defining default operations, do

---

## rule of 5(6)

> If you define or =delete any default operation, define or =delete them all

---

## class prototypes:

```cpp
class normal
{
public:
    // rule of zero
};
```

```cpp
class container
{
public:
    container() noexcept;
    ~container() noexcept;

container(const container& other);
    container(container&& other) noexcept;

container& operator=(const container& other);
    container& operator=(container&& other) noexcept;
};
```

```cpp
class resource_handle
{
public:
    resource_handle() noexcept;
    ~resource_handle() noexcept;

resource_handle(resource_handle&& other) noexcept;
    resource_handle& operator=(resource_handle&& other) noexcept;

resource_handle(const resource_handle&) = delete;
    resource_handle& operator=(const resource_handle&) = delete;
};
```

```cpp
class immoveable
{
public:
    immoveable() noexcept;
    ~immoveable() noexcept;

immoveable(const immoveable&) = delete; 
    immoveable& operator=(const immoveable&) = delete;

immoveable(immoveable&&) = delete;
    immoveable& operator=(immoveable&&) = delete;
};
```

</div>

Source: [Jonathan Müller](https://foonathan.net/2019/02/special-member-functions/)

---

# Thank you

----

---

Take a look at the following code:

```cpp [|4-6,8-10|1,22-27|8,16,20-21]
///options=-std=c++03
struct POD { int i; float f; };

class C {
  POD p;
  int iarr[3];
  double d;
public:
  C() : d(3.14) {
    p.i=2; p.f=22.34;
    for (unsigned i = 0; i < 3; ++i) iarr[i] = i;
  }
};

class D {
public:
  D(C const&, POD const&) {}
};

int main() {
  C c(); 
  D d(C(), POD());
  POD* pp = new POD();
  pp->i = 4;
  pp->f = 22.1;
  float* pf = new float[2];
  pf[0] = 1.2f;
  pf[1] = 2.3f;
}

```

---

## Most vexing parse

```cpp
///hide
struct C{};
struct D{};
struct POD{};
///unhide
C c();            // c: () => C
D d(C(), POD());  // d: (() => C, () => POD) => D
```

---

## Different initialization syntax

```cpp []
///hide
int v = 7;
typedef int X;
///unhide
X t1 = v;     // copy initialization
X t2(v);      // direct initialization
X t3 = { v }; // initialize using initializer list
X t4 = X(v);  // make an X from v and copy it to t4
```

---

## Different initialization syntax

```cpp []
int v = 7;
typedef int X;
X t1 = v;     // ok
X t2(v);      // ok
X t3 = { v }; // ok
X t4 = X(v);  // ok
```

---

## Different initialization syntax

```cpp []
///fails=conversion from 'int' to non-scalar type 'X' requested
int v = 7;
typedef struct { int x; int y; } X;
X t1 = v;     // error
X t2(v);      // error
X t3 = { v }; // ok: X is an aggregate
X t4 = X(v);  // error: we can’t cast an int to a struct
```

---

## Different initialization syntax

```cpp []
///fails=conversion from 'int' to non-scalar type 'X' {aka 'std::vector<int>'} requested
///hide
#include <vector>
///unhide
int v = 7;
typedef std::vector<int> X;
X t1 = v;     // error: constructor is explicit
X t2(v);      // ok
X t3 = { v }; // error: not an aggregate
X t4 = X(v);  // ok (make an X from v and copy it to t4)
```

---

## Different initialization syntax

```cpp []
///fails=invalid conversion from 'int' to 'X' {aka 'int*'}
int v = 7;
typedef int* X;
X t1 = v;     // error
X t2(v);      // error
X t3 = { v }; // error
X t4 = X(v);  // ok: unfortunately converts int to an int*
```

---

## More initialization

```cpp
///hide
struct X {
    X(int);
};
struct Y : X {
    Y(int);
    int m;
};

int v;

void f1() {
///unhide
X(42);                      // create a temporary
///hide
}
///unhide
X f(int v) { return v; }    // return a value
///hide
void f2() {
///unhide
void g(X); g(v);            // pass an argument
new X(v);                   // create object on free store
///hide
}
///unhide
Y::Y(int v) :X(v), m(v) {}  // base and member initializers
///hide
void f3() {
///unhide
throw v;                    // throw an exception 
///hide
}
```

---

# List Initialization

Sources:

- [simplify C++](https://arne-mertz.de/2015/07/new-c-features-uniform-initialization-and-initializer_list/)
- [N2215](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2007/n2215.pdf)

<div>

---

## Initialize (almost) anything with `{}`

```cpp
///hide
struct X {
    X(int);
};
struct Y : X {
    Y(int);
    int m;
};

int v;

void f1() {
///unhide
X{42};                      // create a temporary
///hide
}
///unhide
X f(int v) { return {v}; }  // return a value
///hide
void f2() {
///unhide
void g(X); g({v});          // pass an argument
new X{v};                   // create object on free store
///hide
}
///unhide
Y::Y(int v) :X{v}, m{v} {}  // base and member initializers
```

This is still forbidden:

```cpp
///fails=expected primary-expression before '{' token
///hide
void f3() {
int v = 42;
///unhide
throw {v};                  // throw an exception 
///hide
}
```

---

# It's also safer

```cpp
///fails=narrowing conversion
int i1(4.2); // no problem
int i2{4.2}; // error: narrowing conversion

double d;
float f1(d); // no problem
float f2{d}; // error: narrowing conversion

float f3(i1); // no problem
float f4{i1}; // error: narrowing conversion

unsigned int ui1(-1); // no problem
unsigned int ui2{-1}; // error: narrowing conversion
```

---

## Now, with list initialization

```cpp [8,17-20]
struct POD { int i; float f; };

class C {
  POD p;
  int iarr[3];
  double d;
public:
  C() : p{2, 22.34}, iarr{0, 1, 2}, d{3.14} {}
};

class D {
public:
  D(C const&, POD const&) {}
};

int main() {
  C c{}; 
  D d{C(), POD()};
  POD* pp = new POD{4, 22.1};
  float* pf = new float[2]{1.2f, 2.3f};
}

```

---

## Creating an array

```cpp
///options=-std=c++03
///hide
#include <string>

int main(){
///unhide
std::string days[] = { 
  "Sunday", 
  "Monday", 
  "Tuesday", 
  "Wednesday", 
  "Thursday", 
  "Friday", 
  "Saturday" 
};
///hide
}
```

---

## Creating a vector

```cpp
///options=-std=c++03
///hide
#include <string>
#include <vector>

int main(){
///unhide
std::vector<std::string> days;
days.reserve(7);

days.push_back("Sunday"); 
days.push_back("Monday"); 
days.push_back("Tuesday"); 
days.push_back("Wednesday"); 
days.push_back("Thursday"); 
days.push_back("Friday"); 
days.push_back("Saturday");
///hide
}
```

---

### `std::initializer_list<T>`

- A lightweight proxy object that provides access to an array of objects of type const T.
- Constructed automatically by the compiler when 
  - calling a constructor/function accepting `std::initializer_list`
  - binding a `braced-init-list` to auto

---

## Example

```cpp [|4,16|10,17]
///hide
#include <vector>
#include <iostream>
///unhide
template <class T>
struct S {
    std::vector<T> v;
    S(std::initializer_list<T> l) : v(l) {
         std::cout 
          << "constructed with a " 
          << l.size() 
          << "-element list\n";
    }
    void append(std::initializer_list<T> l) {
        v.insert(end(v), begin(l), end(l));
    }
};

int main() {
  S<int> s = {1, 2, 3, 4, 5};
  s.append({6, 7, 8});
}

```

---

## and

```cpp
///hide
#include <string>
#include <vector>

int main(){
///unhide
std::vector<std::string> days { 
  "Sunday", 
  "Monday", 
  "Tuesday", 
  "Wednesday", 
  "Thursday", 
  "Friday", 
  "Saturday" 
};
///hide
}
```

---

## or even

```cpp
///hide
#include <map>
#include <string>

int main() {
std::string s1;
///unhide
std::map<int, std::string> m = {
        {1, "a"},
        {2, {'a', 'b', 'c'} },
        {3, s1}
};
///hide
}
```

---

## `initializer_list` constructor is preferred

```cpp
///hide
#include <vector>
#include <cassert>

int main() {
///unhide
std::vector<int> aDozenOfFives(12, 5);
std::vector<int> twelveAndFive{12, 5};
assert(aDozenOfFives != twelveAndFive);
///hide
}
```

---

## Range-based for loop

Instead of

```cpp [2-4]
///hide
#include <vector>
#include <iostream>
///unhide
void print(const std::vector<int>& v){
  for (auto it = begin(v); it != end(v); ++it) {
    std::cout << *it << ' ';
  }
  std::cout << '\n';
}
```

write

```cpp [2-4]
///hide
#include <vector>
#include <iostream>
///unhide
void print(const std::vector<int>& v){
  for (const auto& i: v) {
    std::cout << i << ' ';
  }
  std::cout << '\n';
}
```

---

## with `std::initializer_list`

```cpp
///hide
#include <iostream>
int main(){
///unhide
for (auto x : {-1, -2, -3})
  std::cout << x << ' ';
std::cout << '\n';
///hide
}
```

---

## Note

```cpp [7-13]
///hide
#include <initializer_list>
#include <type_traits>

///unhide
template<typename Expected, typename Actual>
void hasType(const Actual &) {
  static_assert(std::is_same<Actual, Expected>::value,
                "should be the same");
}

///hide
int main() {
///unhide
int i1{42};
auto i2{42};
hasType<int>(i2);

int i3 = {42};
auto i4 = {42};
hasType<std::initializer_list<int>>(i4);
///hide
}
```

Note: 
This initialization syntax is frequently referred to as "Uniform initialization". For these reasons, it is not always advised to use this syntax.

---

## note

a *braced-init-list* does not have a type in itself:

```cpp
///fails=no matching function for call to 'do_sth(<brace-enclosed initializer list>)'
template <typename T>
void do_sth(T t);

///hide
void foo() {
///unhide
do_sth({1, 2, 3, 4, 5}); // error: couldn't infer template argument
///hide
}
```

---

## note

Does not support moves

```cpp
///hide
#include <vector>
#include <iostream>

///unhide
struct S {
  S() { std::cout << "default\n"; }
  S(const S&) { std::cout << "copy\n"; }
  S(S&&) { std::cout << "move\n"; }
};

///hide
int main() {
///unhide
std::vector<S> v{S(), S(), S()};
///hide
}
```

```cpp
///compiler=g83
///fails=use of deleted function 'S::S(const S&)'
///hide
#include <vector>
#include <iostream>

///unhide
struct S {
  S() { std::cout << "default\n"; }
  S(const S&) = delete;
  S(S&&) { std::cout << "move\n"; }
};

///hide
void foo() {
///unhide
std::vector<S> v{S(), S(), S()}; // error
///hide
}
```

</div>

---

----

---

## from Boost::Thread library

```cpp
///libs=boost:173
///hide
#include <boost/thread/pthread/thread_data.hpp>
#include <boost/thread/detail/is_convertible.hpp>
#include <boost/bind.hpp>
///unhide
namespace boost {

class thread {
///hide
  boost::detail::thread_data_ptr thread_info;
  struct dummy;
  void start_thread();

///unhide
  template <class F,class A1>
  thread(F f,A1 a1,
         typename disable_if<boost::thread_detail::is_convertible<F&,thread_attributes >, dummy* >::type=0):
      thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1)))
  {
      start_thread();
  }
  template <class F,class A1,class A2>
  thread(F f,A1 a1,A2 a2):
      thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2)))
  {
      start_thread();
  }

template <class F,class A1,class A2,class A3>
  thread(F f,A1 a1,A2 a2,A3 a3):
      thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3)))
  {
      start_thread();
  }

template <class F,class A1,class A2,class A3,class A4>
  thread(F f,A1 a1,A2 a2,A3 a3,A4 a4):
      thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4)))
  {
      start_thread();
  }

template <class F,class A1,class A2,class A3,class A4,class A5>
  thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5):
      thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5)))
  {
      start_thread();
  }

template <class F,class A1,class A2,class A3,class A4,class A5,class A6>
  thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6):
      thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6)))
  {
      start_thread();
  }

template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7>
  thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7):
      thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7)))
  {
      start_thread();
  }

template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8>
  thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8):
      thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8)))
  {
      start_thread();
  }

template <class F,class A1,class A2,class A3,class A4,class A5,class A6,class A7,class A8,class A9>
  thread(F f,A1 a1,A2 a2,A3 a3,A4 a4,A5 a5,A6 a6,A7 a7,A8 a8,A9 a9):
      thread_info(make_thread_info(boost::bind(boost::type<void>(),f,a1,a2,a3,a4,a5,a6,a7,a8,a9)))
  {
      start_thread();
  }
};

} // namespace boost
```

---

## common `printf` bug

```cpp
///compiler=g75
#include <cstdio>
#include <string>

std::string getName() {
  return "Dvir";
}

///hide
int main() {

///unhide
printf("Hello %s", getName());
///hide

}
```

---

## Variadic templates

Sources:
- [N2080](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2006/n2080.pdf)
- [cppreference](https://en.cppreference.com/w/cpp/language/parameter_pack)
- [Fluent{C++}](https://www.fluentcpp.com/2019/02/05/how-to-define-a-variadic-number-of-arguments-of-the-same-type-part-3/)

<div>

---

## variadic type

```cpp
template<typename... Args> struct count;
```

<div class="fragment highlight bottom" style="background-color:#d7d7d747; height:5em; width:9.5em; top: 1em; left: -8.2em">
parameter pack
</div>

</div>

---

## base specialization

```cpp
///hide
#include <cstddef>
template<typename... Args> struct count;
///unhide
template<>
struct count<> {
  static const size_t value = 0;
};
```

---

## recursive case

```cpp
///hide
#include <cstddef>
template<typename... Args> struct count;
///unhide
template<typename T, typename... Args>
struct count<T, Args...>
{
  static const size_t value = 1 + count<Args...>::value;
};
```

<div class="fragment highlight bottom" style="background-color:#d7d7d747; height: 5em; width: 4.3em; top: 2.5em; left: 7.2em">
pack expansion
</div>

</div>

---

## check

```cpp [14-15]
///hide
#include <cstddef>
///unhide
template<typename... Args> struct count;

template<>
struct count<> {
  static const size_t value = 0;
};

template<typename T, typename... Args>
struct count<T, Args...>
{
  static const size_t value = 1 + count<Args...>::value;
};

static_assert(count<int, int, double>::value == 3, 
              "3 elements");
```

---

## `sizeof...`

```cpp
///hide
#include <cstddef>

///unhide
template<typename... Args> struct count 
{
  static const size_t value = sizeof...(Args);
};

static_assert(count<int, int, double>::value == 3, 
              "3 elements");
```

Note: Args is not expanded

---

## type safe `printf`

```cpp []
///hide
#include <iostream>

///unhide
template<typename T, typename... Args>
void tprintf(const char* format, T value, Args... args)
{
    for ( ; *format != '\0'; format++ ) {
        if ( *format == '%' ) {
           std::cout << value;
           tprintf(format+1, args...); // recursive call
           return;
        }
        std::cout << *format;
    }
}
```

---

## with recursion base

```cpp []
///hide
#include <iostream>

///unhide
void tprintf(const char* format) { std::cout << format; }

template<typename T, typename... Args>
void tprintf(const char* format, T value, Args... args)
{
    for ( ; *format != '\0'; format++ ) {
        if ( *format == '%' ) {
           std::cout << value;
           tprintf(format+1, args...); // recursive call
           return;
        }
        std::cout << *format;
    }
}
```

---

## without copy

```cpp []
///hide
#include <iostream>

///unhide
void tprintf(const char* format) { std::cout << format; }

template<typename T, typename... Args>
void tprintf(const char* format, T value, const Args&... args)
{
    for ( ; *format != '\0'; format++ ) {
        if ( *format == '%' ) {
           std::cout << value;
           tprintf(format+1, args...); // recursive call
           return;
        }
        std::cout << *format;
    }
}
```

---

## compiler generated "recursion"

```cpp
///hide
#include <iostream>

void tprintf(const char* format)
{
    std::cout << format;
}

///unhide
int main() {
  tprintf("% world% %\n", "Hello", '!', 123);

// compiler generates
  // tprintf("% world% %\n", "Hello", '!', 123);
  // tprintf(" world% %\n", '!', 123);
  // tprintf(" %\n", 123);
  // tprintf("\n");
}
```

---

## new `boost::thread`

```cpp
///libs=boost:173
///hide
#include <boost/thread/pthread/thread_data.hpp>
#include <boost/thread/detail/is_convertible.hpp>
#include <boost/bind.hpp>
///unhide
namespace boost {

class thread {
///hide
  boost::detail::thread_data_ptr thread_info;
  struct dummy;
  void start_thread();

///unhide
  template <class F, class Arg, class ...Args>
  thread(F&& f, Arg&& arg, Args&&... args) :
    thread_info(make_thread_info(
      thread_detail::decay_copy(boost::forward<F>(f)),
      thread_detail::decay_copy(boost::forward<Arg>(arg)),
      thread_detail::decay_copy(boost::forward<Args>(args))...)
    )
  {
    start_thread();
  }
};

} // namespace boost
```

---

## more pack expansions

```cpp [1|2|3|4-7|8-9]
///hide
template<typename... Args> void f(Args...);
template<typename... Args> void h(Args...);
template<typename... Args>
void foo(Args... args) {
auto n = 0;
///unhide
f(&args...); // f(&E1, &E2, &E3)
f(n, ++args...); // f(n, ++E1, ++E2, ++E3);
f(++args..., n); // f(++E1, ++E2, ++E3, n);
f(const_cast<const Args*>(&args)...);
// f(const_cast<const E1*>(&X1), 
//   const_cast<const E2*>(&X2), 
//   const_cast<const E3*>(&X3))
f(h(args...) + args...);
// f(h(E1,E2,E3) + E1, h(E1,E2,E3) + E2, h(E1,E2,E3) + E3)
///hide
}
```

Note: last is nested

---

## non-type template parameter pack

```cpp
template<typename... Ts, int... N>
void g(Ts (&...arr)[N]) {}

///hide
int main() {
///unhide
int n[1];
g("a", n); // Ts (&...arr)[N] expands to 
           // const char (&)[2], int(&)[1]
///hide
}
```

---

## Base specifiers and member initializer lists

```cpp
template<class... Mixins>
class X : public Mixins... {
 public:
    X(const Mixins&... mixins) : Mixins(mixins)... { }
};
```

---

## `std::tuple`

a variadic pair

```cpp
template< class... Types >
class tuple;
```

---

## return multiple values

```cpp [|1|3|9-13]
///hide
#include <tuple>
#include <string>
#include <iostream>

///unhide
std::tuple<double, char, std::string> get_student(int id)
{
    if (id == 0) return std::make_tuple(3.8, 'A', "Lisa Simpson");
    if (id == 1) return std::make_tuple(2.9, 'C', "Milhouse Van Houten");
    if (id == 2) return std::make_tuple(1.7, 'D', "Ralph Wiggum");
    throw std::invalid_argument("id");
}

///hide
int main() {
///unhide
auto student0 = get_student(0);
std::cout << "ID: 0, "
          << "GPA: " << std::get<0>(student0) << ", "
          << "grade: " << std::get<1>(student0) << ", "
          << "name: " << std::get<2>(student0) << '\n';
///hide
}
```

---

## `std::tie`

```cpp [9-16]
///hide
#include <tuple>
#include <string>
#include <iostream>

///hide
int main() {
///unhide
double gpa1;
char grade1;
std::string name1;
std::tie(gpa1, grade1, name1) = get_student(1);
std::cout << "ID: 1, "
          << "GPA: " << gpa1 << ", "
          << "grade: " << grade1 << ", "
          << "name: " << name1 << '\n';
///hide
}
```

Note: creates a tuple of references

---

## `std::ignore`

```cpp [|3]
///hide
#include <iostream>
#include <string>
#include <set>
#include <tuple>
 
int main()
{
///unhide
std::set<std::string> set_of_str;
bool inserted = false;
std::tie(std::ignore, inserted) = set_of_str.insert("Test");
if (inserted) {
    std::cout << "Value was inserted successfully\n";
}
///hide
}
```

---

## avoiding recursion

```cpp
///hide
#include <cassert>
///unhide
int sum() {
  return 0;
}

template<typename T, typename... Args>
int sum(const T& t, const Args&... args)
{
  return t + sum(args...);
}

///hide
int main() {
///unhide
assert(sum(1, 2, 3) == 6);
///hide
}
```

---

## `std::initializer_list` for the rescue

```cpp
///hide
#include <cassert>
#include <initializer_list>

///unhide
template<typename... Args>
int sum(const Args&... args)
{
  auto res = 0;
  (void)std::initializer_list<int>{(res += args, 0)...};
  return res;
}

///hide
int main() {
///unhide
assert(sum(1, 2, 3) == 6);
///hide
}
```

Note: C++17 has fold expressions

---

# variadic arguments of the same type

---

## Solution #1

`std::initializer_list`

```cpp
///hide
#include <cassert>
#include <initializer_list>

///unhide
int sum(std::initializer_list<int> ints);

///hide
void foo() {
///unhide
assert(sum({1, 2, 3}) == 6);
// sum({1, 2, "3"}); // fails to compile
///hide
}
```

---

```cpp
#include <type_traits>

template<class...> struct conjunction : std::true_type { };

template<class B1> struct conjunction<B1> : B1 { };

template<class B1, class... Bn>
struct conjunction<B1, Bn...> 
    : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
```

Note: in the standard from C++17

---

## Solution #2

`static_assert`

```cpp
///hide
#include <type_traits>
#include <cassert>

template<class...> struct conjunction : std::true_type { };
template<class B1> struct conjunction<B1> : B1 { };
template<class B1, class... Bn>
struct conjunction<B1, Bn...> 
    : std::conditional<bool(B1::value), conjunction<Bn...>, B1>::type {};
///unhide

template<typename... Args>
int sum(const Args&... args) {
  static_assert(conjunction<std::is_same<Args, int>...>::value, 
                "all arguments should be int");
}

///hide
void foo() {
///unhide
assert(sum(1, 2, 3) == 6);
// sum(1, 2, "3"); // fails to compile
///hide
}
```

---

## SFINAE

"Substitution Failure Is Not An Error"

```cpp [|2,9|5,9]
template<typename T>
void f(T x, typename T::type y);
 
template<typename T>
void f(T x, typename T::other_type y);

struct A
{
    using type = int;
};

///hide
void foo() {
///unhide
f(A(), 42);
///hide
}
```

---

`std::enable_if`

```cpp
template<bool B, class T = void>
struct enable_if {};
 
template<class T>
struct enable_if<true, T> { 
  typedef T type; 
};
```

---

## Solution #3

SFINAE

```cpp
///hide
#include <type_traits>
#include <cassert>

///unhide
template<typename... Ts>
using AllInts = typename std::enable_if<
  conjunction<std::is_same<Ts, int>...>::value
  >::type;

template<typename... Args, typename = AllInts<Args...>>
int sum(const Args&... args);

///hide
void foo() {
///unhide
assert(sum(1, 2, 3) == 6);
// sum(1, 2, "3"); // fails to compile
///hide
}
```

---

----

---

## count odds

> Given a vector of integers, count the number of odd items.

```cpp
///hide
#include <vector>

///unhide
int count_odds(const std::vector<int>& v);
```

---

## First try

```cpp
///hide
#include <vector>

///unhide
int count_odds(const std::vector<int>& v)
{
    int ret = 0;
    for (auto it = v.begin(); 
         it != v.end(); 
         ++it)
    {
        if ((*it & 1) == 1)
            ++ret;
    }
    
    return ret;
}
```

---

Don't reinvent the wheel

---

## `#include <algorithm>`

```cpp
///hide
#include <iterator>

///unhide
template<class InputIterator, class Predicate>
typename std::iterator_traits<InputIterator>::difference_type
count_if(InputIterator first, InputIterator last, Predicate pred);
```

> Returns the number of iterators it in the range `[first, last)` for which the following condition hold: 
> `pred(*it) != false`

---

## `#include <algorithm>`

```cpp
///hide
#include <iterator>

///unhide
template<class InputIterator, class Predicate>
typename std::iterator_traits<InputIterator>::difference_type
count_if(InputIterator first, InputIterator last, Predicate pred);
```

In our case `pred` should have the following signature:

```cpp
bool pred(int i);
```

---

## Write a function

```cpp []
///hide
#include <vector>
#include <algorithm>

///unhide
bool isOdd(int i)
{
    return (i & 1) == 1;
}

int count_odds(const std::vector<int>& v)
{
    return std::count_if(v.begin(), v.end(), isOdd);
}
```

---

## Write a function object

```cpp []
///hide
#include <vector>
#include <algorithm>

///unhide
struct IsOdd
{
    bool operator()(int i)
    {
        return (i & 1) == 1;
    }
};

int count_odds(const std::vector<int>& v)
{
    return std::count_if(v.begin(), v.end(), IsOdd());
}
```

---

## So, what’s the problem?

Creating functions or function objects can be a lot of effort, especially if the function/function object is only used in one specific place.

These functions and function objects also unnecessarily ‘clutter up’ the code.

---

# Lambda expressions

---

## Do it `λ`-style!

```cpp
///hide
#include <vector>
#include <algorithm>

///unhide
int count_odds(const std::vector<int>& v)
{
    return std::count_if(v.begin(), v.end(), [](int i)->bool
    {
        return (i & 1) == 1;
    });
}
```

---

## Syntax

<div class="fragment highlight top" style="background-color:#1b91ff3d; height:5em; width:5em; top: -3em; left: -16em">
introducer
</div>

<div class="fragment highlight top" style="background-color:#42affa40; height:5em; width:7em; top: -3em; left: -8em">
(optional) parameter list
</div>

<div class="fragment highlight top" style="background-color:#8dcffc57; height:5em; width:7em; top: -3em; left: 2em">
(optional) return type
</div>

```cpp
///hide
void foo() {
///unhide
[]          (int i)          ->bool

{ return (i & 1) == 1; }
///hide
;
}
```

</div>

---

## behind the scenes

```cpp
///hide
void foo() {
///unhide
[](int i)->bool
{
    return (i & 1) == 1;
}
///hide
;
}
```

is translated to

```cpp [|4]
class __compiler_generated_name__
{
public: 
    inline bool operator()(int i) const
    {
      return (i & 1) == 1;
    }
};
```

---

## Named lambda

```cpp [2-5|7,9]
///hide
#include <vector>
#include <algorithm>
#include <cassert>

///unhide
void remove_odds(std::vector<int> &v) {
    auto isOdd = [](int i)
    {
        return (i & 1) == 1;
    };

v.erase(std::remove_if(v.begin(), v.end(), isOdd), v.end());

assert(std::count_if(v.begin(), v.end(), isOdd) == 0);
}
```

---

## increment vector

> Given an integer and a vector, add the integer to every element of the vector.

```cpp
///hide
#include <vector>

///unhide
void add_to_vector(std::vector<int>& v, int added);
```

---

## `std::for_each`

```cpp
template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function fn);
```

> Applies function `fn` to each of the elements in the range `[first,last)`.

---

## `std::for_each`

```cpp
template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last, Function fn);
```

In our case `fn` should have the following signature:

```cpp
void fn(int& i);
```

---

## First try

```cpp
///fails='added' is not captured
///hide
#include <vector>
#include <algorithm>

///unhide
void add_to_vector_wrong(std::vector<int>& v, int added)
{
    std::for_each(v.begin(), v.end(), [](int& i)
    {
        i += added;
    });
}
```

---

## Using a function object

```cpp
///hide
#include <vector>
#include <algorithm>

///unhide
struct Add
{
    int m_added;
    Add(int added) : m_added(added) {}
    void operator()(int& i)
    {
        i += m_added;
    }
};

void add_to_vector_struct(std::vector<int>& v, int added)
{
    std::for_each(v.begin(), v.end(), Add(added));
}
```

---

## Capture that

```cpp
///hide
#include <vector>
#include <algorithm>

///unhide
void addToVector(std::vector<int>& v, int added)
{
    std::for_each(v.begin(), v.end(), [added](int& i)
    {
        i += added;
    });
}
```

---

### new number -> string conversions

```cpp [2-7,10-11|8-9]
#include <string>

struct Employee {
    int id;
    double salary;

std::string to_string() const {
        return std::string{"Employee ID: "} + std::to_string(id) 
            + ", Salary: " + std::to_string(salary);
    }
};
```

-  no base support
-  return value may differ from what `std::cout` prints by default
-  relies on the current locale for formatting purposes

---

### new string -> number conversions

```cpp [11-15]
#include <string>

struct Employee {
    int id;
    double salary;

Employee(const std::string& str) {
        const auto next_numeric = [](const std::string& s) {
            return s.substr(s.find_first_of("0123456789"));
        };
        const auto id_start = next_numeric(str);
        auto id_end = size_t{};
        id = std::stoi(id_start, &id_end, 10);
        const auto salary_start = next_numeric(id_start.substr(id_end));
        salary = std::stod(salary_start);
    }
};
```

-   throws if conversion failed
-   relies on the current locale for formatting purposes

---

## By reference

```cpp
///hide
#include <vector>
#include <algorithm>
#include <string>

///unhide
std::string to_string(const std::vector<int>& v)
{
    std::string s;
    std::for_each(v.begin(), v.end(), [&s](int i)
    {
        s += std::to_string(i) + " ";
    });
    return s;
}
```

---

## Capturing members

```cpp [|3,10-12]
///hide
#include <algorithm>

///unhide
struct ContainerIncrementer
{
    int m_x;
    ContainerIncrementer(int x) : m_x(x) {}
    template<typename Container>
    void increment(Container& cont)
    {
        std::for_each(std::begin(cont), 
                      std::end(cont), 
                      [this](int& val) {
                        val += m_x;
                      }
        );
    }
};
```

---

## Default captures

|||
|-|-|
| `[&]` | Capture any referenced variable by reference |
| `[=]` | Capture any referenced variable by making a copy |
| `[=, &foo]` | Capture any referenced variable by making a copy, but capture variable foo by reference |

---

## fill vector

> fill a given vector with the numbers 0,1,2,...

---

## `#include <numeric>`

```
template< class ForwardIt, class T >
void iota( ForwardIt first, ForwardIt last, T value );
```

> Fills the range `[first, last)` with sequentially increasing values, starting with `value`.

---

## fill vector

```cpp [5]
#include <numeric>
#include <vector>

void fill_vector(std::vector<int>& v) {
    std::iota(v.begin(), v.end(), 0);
}
```

---

## fill vector

> fill a given vector with the numbers 0,2,4,...

---

## `#include <algorithm>`

```
template< class ForwardIt, class Generator >
void generate( ForwardIt first, ForwardIt last, Generator g );
```

> Assigns each element in range `[first, last)` a value generated by the given function object `g`.

---

## fill vector

```cpp [5-10]
///fails=assignment of read-only variable 'i'
#include <algorithm>
#include <vector>

void fill_vector(std::vector<int>& v) {
    int i = 0;
    std::generate(v.begin(), v.end(), [i]{
        const auto next = i;
        i += 2;
        return next;
    });
}
```

---

## fill vector

```cpp [8]
///fails=assignment of read-only variable 'i'
#include <algorithm>
#include <vector>

void fill_vector(std::vector<int>& v) {
    int i = 0;
    std::generate(v.begin(), v.end(), [i]{
        const auto next = i;
        i += 2; // error: assignment of read-only variable 'i'
        return next;
    });
}
```

---

## mutable lambda

```cpp [6]
#include <algorithm>
#include <vector>

void fill_vector(std::vector<int>& v) {
    int i = 0;
    std::generate(v.begin(), v.end(), [i]() mutable {
        const auto next = i;
        i += 2;
        return next;
    });
}
```

---

## capture init (C++14)

```cpp [5]
#include <algorithm>
#include <vector>

void fill_vector(std::vector<int>& v) {
    std::generate(v.begin(), v.end(), [i = 0]() mutable {
        const auto next = i;
        i += 2;
        return next;
    });
}
```

---

## Higher order lambda

```cpp
///hide
#include <iostream>
#include <string>

///unhide
auto add_prefix(const std::string &prefix) {
    return [&prefix](const std::string s) {
        return prefix + s;
    };
}

///hide
int main() {
///unhide
std::cout << add_prefix("Hello ")("World") << '\n';
///hide
}
```

---

## careful

```cpp
///compiler=clang600
///hide
#include <iostream>
#include <string>

///unhide
auto add_prefix(const std::string &prefix) {
    return [&prefix](const std::string s) {
        return prefix + s;
    };
}

///hide
int main() {
///unhide
const auto prefixer = add_prefix("Hello ");
std::cout << prefixer("World") << '\n';
///hide
}
```

---

## C++ Core Guidelines [F.53](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rf-value-capture)

> Avoid capturing by reference in lambdas that will be used non-locally, including returned, stored on the heap, or passed to another thread

---

## C++ Core Guidelines [Con.1](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#Rconst-immutable)

> By default, make objects immutable

---

## it's complicated

```cpp []
///hide
#include <iostream>
#include <string>

///unhide
void draw_upper_case() {
    std::string s;
    for (char c; std::cin >> c; ) {
        s += toupper(c);
    }

// draw text
}
```

---

## it's complicated

```cpp [2-8]
///hide
#include <iostream>
#include <string>

///unhide
void draw_upper_case() {
    const auto s = [&] {
        std::string s;
        for (char c; std::cin >> c; ) {
            s += toupper(c);
        }
        return s;
    }();

// draw text
}
```

---

## `#include <algorithm>`

```cpp [4-7]
///hide
#include <iostream>
#include <string>
#include <algorithm>
#include <iterator>

///unhide
void draw_upper_case() {
    const auto s = [&] {
        std::string s;
        std::transform(std::istream_iterator<char>{std::cin}, 
                       std::istream_iterator<char>{},
                       std::back_inserter(s),
                       toupper);
        return s;
    }();

// draw text
}
```

---

## C++ Core Guidelines [ES.28](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#es28-use-lambdas-for-complex-initialization-especially-of-const-variables)

> Use lambdas for complex initialization, especially of `const` variables

---

# legacy code

---

Many libraries have such an interface

```cpp []
typedef int(*callback)(char*, int);
void register_callback(callback cb);
```

How can we call this with a lambda?

---

A capture-less lambda can be converted to a function pointer

```cpp []
///hide
int read_count = 42;

///unhide
typedef int(*callback)(char*, int);
void register_callback(callback cb);

///hide
void register_callback(callback cb) { cb(nullptr, 0); }

int main(){
///unhide
register_callback([](char* buffer, int size) {
    /// read into buffer
    return read_count;
});
///hide
}
```

---

For capturing lambda we can add a level of indirection if the library supports user data

```cpp [1-2|4-8|9-11]
///hide
#include <fstream>
int read_count = 42;

///unhide
typedef int(*callback)(const char*, int, void*);
void register_callback(callback cb, void* userdata);

///hide
void register_callback(callback cb, void* userdata) { cb(nullptr, 0, userdata); }

int main(){
///unhide
std::fstream f;
auto cb = [&f](const char* buffer, int size) {
    /// read from f into buffer
    return read_count;
};
register_callback([](const char* buffer, int size, void* userdata){
    return (*static_cast<decltype(cb)*>(userdata))(buffer, size);
}, &cb);
///hide
}
```

Note: need to keep `cb` alive while the callback is active

---

## Let's benchmark

[Benchmark 1](https://quick-bench.com/q/lGVLy95a_GURGh2BJAuC9qKwFS4)

[Benchmark 2](https://quick-bench.com/q/19wvZEycM8eMDSXe5PVn4TUwstw)

Note: wrong `value_type` on the first

---

## Generic Lambda (C++14)

```cpp
///hide
void foo() {
///unhide
[](const auto& a, auto& b){
    b += a;
}
///hide
;
}
```

is translated to

```cpp [4-5]
class __compiler_generated_name__
{
public: 
    template<typename A, typename B>
    inline void operator()(const A& a, B& b) const
    {
      return b += a;
    }
};
```

---

## Templated Lambda (C++20)

e.g. to force the same type

```cpp
///hide
void foo() {
///unhide
[]<typename T>(const T& a, T& b){
    b += a;
}
///hide
;
}
```

---

## Storing lambda

```cpp []
///hide
template<typename Lambda>
///unhide
class CallbackHolder {
public:
    CallbackHolder(Lambda callback) 
        : m_callback{callback} 
    {}

void call() {
        m_callback();
    }

Lambda m_callback;
};
```

---

## Storing lambda

templatize

```cpp []
///hide
#include <utility>

///unhide
template<typename Lambda>
class CallbackHolder {
public:
    CallbackHolder(Lambda callback) 
        : m_callback{callback} 
    {}

void call() {
        m_callback();
    }

Lambda m_callback;
};

template<typename Lambda>
CallbackHolder<Lambda> make_holder(Lambda&& lambda) {
    return { std::forward<Lambda>(lambda) };
}

///hide
int main() {
///unhide
auto holder = make_holder([](){ return 42; });
///hide
}
```

---

## Storing lambda

`std::function`

```cpp []
#include <functional>

class CallbackHolder {
public:
    CallbackHolder(std::function<void()> callback) 
        : m_callback{callback} 
    {}

void call() {
        m_callback();
    }

std::function<void()> m_callback;
};

///hide
int main() {
///unhide
CallbackHolder holder{[](){ return 42; }};
///hide
}
```

---

## `std::function`

A general-purpose polymorphic function wrapper.

```cpp
///hide
template<typename... Ts> class function;

///unhide
template< class R, typename... Args >
class function<R(Args...)>;
```

Can store any `Callable` which receives `Args` and returns `R`.

---

## Examples

Free function

```cpp []
///hide
#include <functional>

///unhide
long floor(double d) { return d; }

int main(){
    std::function<long(double)> f = floor;
    return f(4.2);
}
```

---

## Examples

Lambda

```cpp []
///hide
#include <functional>

///unhide
auto floor = [](double d)->int { return d; };

int main(){
    std::function<long(double)> f = floor;
    return f(4.2);
}
```

---

## Examples

Function abject

```cpp []
///hide
#include <functional>

///unhide
struct floor{
    long operator()(double d) { return d; }
};

int main(){
    std::function<long(double)> f = floor{};
    return f(4.2);
}
```

---

## Examples

Member function

```cpp []
///hide
#include <functional>

///unhide
struct floor{
    floor(double d) : m_d{d} {}
    long calc() const { return m_d; }
    double m_d;
};

int main(){
    std::function<long(const floor&)> f = &floor::calc;
    return f(floor{4.2});
}
```

---

## Examples

Member variable

```cpp []
///hide
#include <functional>

///unhide
struct floor{
    floor(double d) : m_d{d} {}
    long calc() const { return m_d; }
    double m_d;
};

int main(){
    std::function<double(const floor&)> f = &floor::m_d;
    return f(floor{4.2});
}
```

---

## virtual function

```cpp []
///hide
#include <cassert>

///unhide
struct Base {
    virtual ~Base() = default;
    virtual int get() const { return 1; }
};

struct Derived : Base {
    virtual int get() const { return 2; }
};

///hide
int main() {
///unhide
Base* p = new Derived();
assert(p->get() == 2);
///hide
}
```

---

## changing signature

```cpp [3,7,11]
///fails=Assertion `p->get(0) == 2' failed
///hide
#include <cassert>

///unhide
struct Base {
    virtual ~Base() = default;
    virtual int get(int i) const { return i + 1; }
};

struct Derived : Base {
    virtual int get() const { return 2; }
};

///hide
int main() {
///unhide
Base* p = new Derived();
assert(p->get(0) == 2);
///hide
}
```

---

## proper compiler error

```cpp [7]
///fails='int Derived::get() const' marked 'override', but does not override
///hide
#include <cassert>

///unhide
struct Base {
    virtual ~Base() = default;
    virtual int get(int i) const { return i + 1; }
};

struct Derived : Base {
    int get() const override { return 2; } // error
};

///hide
int main() {
///unhide
Base* p = new Derived();
assert(p->get(0) == 2);
///hide
}
```

---

## disable override

```cpp [7,11]
///fails=virtual function 'virtual int Grandson::get(int) const' overriding final function
///hide
#include <cassert>

///unhide
struct Base {
    virtual ~Base() = default;
    virtual int get(int i) const { return i + 1; }
};

struct Derived : Base {
    int get(int) const final { return 2; }
};

struct Grandson : Derived {
    int get(int) const override { return 3; } // error
}
```

---

## C++ Core Guidelines [C.128](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c128-virtual-functions-should-specify-exactly-one-of-virtual-override-or-final)

> Virtual functions should specify exactly one of `virtual`, `override`, or `final`

---

## final class

```cpp [6,10]
///fails=cannot derive from 'final' base 'Derived' in derived type 'Grandson'
///hide
#include <cassert>

///unhide
struct Base {
    virtual ~Base() = default;
    virtual int get(int i) const { return i + 1; }
};

struct Derived final : Base {
    int get(int) const { return 2; }
};

struct Grandson : Derived { // error
}
```

---

## devirtualization

```cpp [10-12]
///hide
#include <cassert>

///unhide
struct Base {
    virtual ~Base() = default;
    virtual int get(int i) const { return i + 1; }
};

struct Derived final : Base {
    int get(int) const { return 2; }
};

int callGet(const Derived& d, int i) { 
  return d.get(i); 
}
```

---

## `std::function` Caveats

* might allocate
* may require two calls through function pointers per invocation

[Benchmark 1](https://quick-bench.com/q/DfBQBz4PrwOceIQZIGbodXAXLz8)

[Benchmark 2](https://quick-bench.com/q/28rParTpVouuPVLZvj4O_4O4do8)

Note: 1st including `std::function` creation

---

## Lambdas

1. make code more readable
2. improve locality of the code
3. allow to store state easily
4. make using algorithms easy
5. get better with each revision

</div>

Source: [Bartek's coding blog](https://www.bfilipek.com/2020/05/lambdasadvantages.html?m=1#5-lambdas-get-better-with-each-revision-of-c)

</div>

---

----

---

## what's printed

```cpp
///hide
#include <string>
#include <iostream>
#include <stdexcept>

///unhide
void process(const std::string& str) {
    auto p = new int;
    *p = std::stoi(str);
    std::cout << *p << '\n';
    delete p;
}

///hide
int main() {
///unhide
try {
    process("ll");
} catch (std::exception& ex) {
    std::cout << ex.what() << '\n';
}
///hide
}
```

---

## what's wrong here

```cpp
///options=-fsanitize=address
///fails=attempting double-free
///hide
#include <string>
#include <iostream>
#include <stdexcept>

///unhide
struct S{
    S(): p{new int} {}
    ~S() { delete p; }
    S(const S& other) : p{other.p} {}

int* p;
};

///hide
int main() {
///unhide
S s1;
S s2 = s1;
///hide
}
```

---

## and here

```cpp
///options=-fsanitize=address
///fails=alloc-dealloc-mismatch
///hide
#include <string>
#include <iostream>
#include <stdexcept>

///unhide
struct S{
    S(): p{new int[10]} {}
    ~S() { delete p; }
    S(S&& other) : p{other.p} { other.p = nullptr; }

int* p;
};

///hide
int main() {
///unhide
S s1;
S s2 = std::move(s1);
///hide
}
```

---

## First solution

---

## Don't heap allocate!

![heap](06_smart_pointers/stop_it.webp)

---

## When to heap-allocate

-  Runtime Polymorphism
-  Decouple compilation units (PIMPL)
-  An object needs to outlive its scope

---

## second solution

---

# Smart pointers

---

## Smart pointers

> a smart pointer is an abstract data type that simulates a pointer while providing additional features, such as automatic memory management or bounds checking.

---

## Ownership

The owner of a dynamically allocated object is the one who is responsible to delete it. 
There are three patterns of object ownership:
- Creator as a Sole Owner
- Sequence of Owners
- Shared Ownership

---

## Creator as a Sole Owner

When a class creates and deletes a resource:

```cpp
///hide
class Object{};

///unhide
struct DumbSingleOwner
{
    DumbSingleOwner() : m_pObject(new Object)
    {}

~DumbSingleOwner()
    {
        delete m_pObject;
    }

Object* m_pObject;
};
```

---

## Use `std::unique_ptr`

```cpp
#include <memory>
///hide

class Object{};
///unhide

struct SmartSingleOwner
{
    SmartSingleOwner() : m_pObject(new Object)
    {}
    std::unique_ptr<Object> m_pObject;
};
```

Note: Keeps the rule of 0

---

## How does it work?

`unique_ptr` deletes the stored object on its destructor.

---

## Testing

```cpp
///hide
#include <iostream>
#include <memory>

///unhide
struct Object
{
    Object(){ std::cout << "Object constructed\n"; }

~Object(){ std::cout << "Object destructed\n"; }
};
///hide

struct DumbSingleOwner
{
    DumbSingleOwner() : m_pObject(new Object)
    {}

~DumbSingleOwner()
    {
        delete m_pObject;
    }

Object* m_pObject;
};

struct SmartSingleOwner
{
    SmartSingleOwner() : m_pObject(new Object)
    {}
    std::unique_ptr<Object> m_pObject;
};
///unhide

int main()
{
    {
        DumbSingleOwner dumb;
    }
    {
        SmartSingleOwner smart;
    } 
}
```

---

## Can be used as a raw pointer

```cpp [4|5|6]
///hide
#include <string>
#include <memory>
#include <iostream>

///unhide
int main()
{
    std::unique_ptr<std::string> pInt(new std::string("Hello"));
    pInt->append(" World");
    if (pInt)
        std::cout << *pInt << '\n';
}
```

---

## other useful methods

- `.get()` - returns the stored pointer
- `.reset()` - replaces the managed object
- `.release()` - returns a pointer to the managed object and releases the ownership

---

## Sequence of Owners

Who should delete the created object?

```cpp
///hide
class Object;

///unhide
class Factory
{
public:
    virtual Object* createObject() = 0;
};
```

---

## The caller?

```cpp
///hide
class Object {};

class Factory
{
public:
    virtual Object* createObject() = 0;
};

///unhide
class FreeSpiritFactory : public Factory
{
public:
    Object* createObject() override
    {
        return new Object;
    }
};
```

---

## The factory?

```cpp
///hide
#include <vector>
#include <algorithm>

class Object {};

class Factory
{
public:
    virtual Object* createObject() = 0;
};

///unhide
class AccountantFactory : public Factory
{
public:
    Object* createObject() override
    {
        m_objects.push_back(new Object);
        return m_objects.back();
    }

~AccountantFactory()
    {
        std::for_each(m_objects.begin(), m_objects.end(), [](Object* p){
            delete p;
        });
    }

private:
    std::vector<Object*> m_objects;
};
```

---

## Use `std::unique_ptr`

Now it is clear the caller gets ownership

```cpp
///hide
#include <memory>

class Object {};

///unhide
class SmartFactory
{
public:
    std::unique_ptr<Object> createObject()
    {
        return std::unique_ptr<Object>{ new Object() };
    }
};
```

---

## How does it work?

- The copy constructor and assignment operator of `std::unique_ptr` are deleted. 
- It only has a move constructor and move assignment operator.
- When moved from, the original `std::unique_ptr` releases the object and the destination `std::unique_ptr` acquires it.

---

## Example

```cpp
///hide
#include <memory>
#include <cassert>

int main() {
///unhide
std::unique_ptr<int> pInt(new int(1)); 
// std::unique_ptr<int> pIntCopy = pInt; // doesn't compile
std::unique_ptr<int> pIntMove = std::move(pInt);
assert(pIntMove && !pInt);
///hide
}
```

---

## Unique array

```cpp [2,4]
///hide
#include <memory>
#include <cstdio>
#include <cstring>

int main() {
///unhide
auto pHello = "Hello World!";
std::unique_ptr<char[]> pCharArray(new char[strlen(pHello) + 1]);
sprintf(pCharArray.get(), pHello);
printf("third letter is %c\n", pCharArray[2]);
///hide
}
```

---

## Shared ownership

What if the factory does want to keep a reference to the created object?

If the factory would return a pointer, the user might already delete it by the time the factory references it!

---

## `emplace_back`

constructs a collection element in place

```cpp [1-8|12|13]
///hide
#include <iostream>
#include <string>
#include <vector>

///unhide
struct S {
    explicit S(const std::string &s): s{s} 
    { std::cout << "Ctor " << s << "\n"; }
    S(S&& other): s{std::move(other.s)} 
    { std::cout << "Move Ctor " << s << "\n"; }

std::string s;
};

///hide
int main() {
///unhide
std::vector<S> v;
v.reserve(2);
v.push_back(S("pushed"));
v.emplace_back("emplaced");
///hide
}
```

---

# `emplace`

```cpp
///hide
#include <string>
#include <map>

int main() {
///unhide
std::map<std::string, std::string> m;
m.emplace("key", "value");
///hide
}
```

---

## Use `std::shared_ptr`

```cpp
///hide
#include <memory>
#include <vector>

class Object {};

///unhide
class SmartAccountant
{
public:
    std::shared_ptr<Object> createObject()
    {
        m_createdObjects.emplace_back(new Object);
        return m_createdObjects.back();
    }

private:
    std::vector<std::shared_ptr<Object>> m_createdObjects;
};
```

---

## How does it work?

The `shared_ptr` works on reference counting, so as long as the factory holds a reference to the created object, it is guaranteed not be deleted.

---

## no free lunch

---

## Counting has its cost

- A counter should be allocated on the heap
- On each copy of the `shared_ptr` the counter is incremented and on each destruction, decremented.

---

## So, what to do?

- Use shared ownership only if you must
- Pass `shared_ptr` by const reference to functions so less copies will occur.
- Allocate with `make_shared`

---

## `std::make_shared`

Instead of:

```cpp
///hide
#include <memory>

int main(){
///unhide
std::shared_ptr<int> pInt1(new int(5));
///hide
}
```

Write:

```cpp
///hide
#include <memory>

int main(){
///unhide
auto pInt2 = std::make_shared<int>(5);
///hide
}
```

---

## Why is it good?

- Allocates the counter together with the object – one less dynamic memory allocation and improved locality.
- Can prevent memory leaks on certain situations.

---

## `std::make_unique`

Similarly, the standard library offers `make_unique` to allocate unique pointers.

```cpp
///hide
#include <memory>
#include <cmath>

int main(){
///unhide
auto pFloat = std::make_unique<float>(INFINITY);
///hide
}
```

Note: to conclude...

---

## C++ Core Guidelines [R.5](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r5-prefer-scoped-objects-dont-heap-allocate-unnecessarily)

> Prefer scoped objects, don’t heap-allocate unnecessarily

---

## C++ Core Guidelines [C.149](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#c149-use-unique_ptr-or-shared_ptr-to-avoid-forgetting-to-delete-objects-created-using-new)

> Use `unique_ptr` or `shared_ptr` to avoid forgetting to delete objects created using new

---

## C++ Core Guidelines [R.11](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r11-avoid-calling-new-and-delete-explicitly)

> Avoid calling `new` and `delete` explicitly

---

## Custom deleters

- By default, smart pointers call `delete` (or `delete[]` in case of `unique_ptr<T[]>`), to free the managed object.
- The user can choose to call any other function.

---

## Shared array

A custom deleter of a `shared_ptr` is sent as a second parameter to the constructor:

```cpp
///options=-std=c++11
///hide
#include <memory>

int main(){
///unhide
auto pSharedArray = std::shared_ptr<int[]>(new int[3], 
[](int* p)
{
    delete[] p;
});
///hide
}
```

---

## Not just memory

Custom deleters enable the standard smart pointers to manage other resources besides memory:

```cpp
///external
///compiler=vcpp_v19_24_x64
///options=/O2
///hide
#include <type_traits>
#include <memory>
///unhide
#include <Windows.h>

///hide

void load() {
///unhide
using LibType = typename std::remove_pointer<HINSTANCE>::type;
auto pLib = std::shared_ptr<LibType>(LoadLibrary("somelib.dll"), FreeLibrary);
if (pLib)
{
    GetProcAddress(pLib.get(), "makeObject");
}
///hide
}
```

---

## `unique_ptr` custom deleter

A custom deleter of a `unique_ptr` should be declared as a second template parameter:

```cpp
///hide
#include <memory>
#include <cstdio>
#include <cstdlib>

int main() {
///unhide
auto pMalloced = std::unique_ptr<char, void(*)(char*)>((char*)malloc(4), 
                                                       [](char* p)
{
    free(p);
});

auto pFile = std::unique_ptr<FILE, int(*)(FILE*)>(fopen("myfile.txt", "wt"), 
                                                  [](FILE* f){
    return fclose(f);
});
fprintf(pFile.get(), "Hello World!");
///hide
}
```

---

## Leaky marriage

```cpp [13-17,21|25-30]
///hide
#include <string>
#include <memory>
#include <iostream>

///unhide
class Person
{
public:
    Person(const std::string& name)
     : m_name(name)
    {
        std::cout << m_name << " created.\n";
    }
    ~Person()
    {
        std::cout << m_name << " destroyed.\n";
    }
    void marry
        (const std::shared_ptr<Person>& spouse)
    {
        m_spouse = spouse;
    }

private:
    std::string              m_name;
    std::shared_ptr<Person>  m_spouse;
};
int main()
{
    auto chandler 
        = std::make_shared<Person>("Chandler");
    auto monica 
        = std::make_shared<Person>("Monica");
    chandler->marry(monica);
    monica->marry(chandler);
}

```

---

## What happened?

![cycle](06_smart_pointers/marriage.svg)

When there is a cycle of `shared_ptr`s pointing to each other, they all keep each other from being destroyed.

---

## use `std::weak_ptr`

Should be constructed from an existing `shared_ptr`:

```cpp
///hide
#include <memory>

int main() {
///unhide
auto pSharedChar = std::make_shared<char>('x');
std::weak_ptr<char> pWeakChar(pSharedChar);
///hide
}
```

---

## `std::weak_ptr`

To access the owned pointer, the user should call `lock()` to get a new `shared_ptr` to the object, if it hasn’t been freed or an empty `shared_ptr` otherwise.

```cpp
///hide
#include <memory>
#include <cstdio>

int main() {
auto pSharedChar = std::make_shared<char>('x');
std::weak_ptr<char> pWeakChar(pSharedChar);
///unhide
if (auto pSharedChar2 = pWeakChar.lock())
{
    printf("%c\n", *pSharedChar2);
}
///hide
}
```

---

## How does it work?

- Each `shared_ptr` contains two counters – one for strong references and another one for weak references.
- When a `shared_ptr` is destroyed, the decision whether to call the deleter is only based on the strong counter.
- The counters themselves are freed when both counters reach 0.

---

## Back to marriage

```cpp [13-17,21]
///hide
#include <string>
#include <memory>
#include <iostream>

///unhide
class Person
{
public:
    Person(const std::string& name)
     : m_name(name)
    {
        std::cout << m_name << " created.\n";
    }
    ~Person()
    {
        std::cout << m_name << " destroyed.\n";
    }
    void marry(
        const std::shared_ptr<Person>& spouse)
    {
        m_spouse = spouse;
    }

private:
    std::string              m_name;
    std::weak_ptr<Person>    m_spouse;
};
int main()
{
    auto chandler 
        = std::make_shared<Person>("Chandler");
    auto monica 
        = std::make_shared<Person>("Monica");
    chandler->marry(monica);
    monica->marry(chandler);
}

```

---

## better for factory

```cpp [12]
///hide
#include <memory>
#include <vector>

class Object{};

///unhide
class SmarterAccountant
{
public:
    std::shared_ptr<Object> createObject()
    {
        auto res = std::make_shared<Object>();
        m_createdObjects.emplace_back(res);
        return res;
    }

private:
    std::vector<std::weak_ptr<Object>> m_createdObjects;
};
```

---

## casting

The standard library provides functions to cast **`shared_ptr`s**:

```cpp [1-9|13-16]
///hide
#include <memory>

///unhide
struct Base
{
    virtual ~Base();
};

struct Derived : public Base
{
    void doSomething() {}
};

void smartDowncaster(const std::shared_ptr<Base>& pBase)
{
    if (auto pDerived = std::dynamic_pointer_cast<Derived>(pBase))
    {
        pDerived->doSomething();
    }
}
```

---

## casting

There's also

- `static_pointer_cast`
- `const_pointer_cast`
- `reinterpret_pointer_cast` (Since C++17)

</div>

Note: Since casting creates a copy of the pointer, it can be used with `shared_ptr`s only! If needed, one can first call `get()` on the `unique_ptr` to get the raw pointer and cast the result, but this is generally considered a bad design.

---

## attributes

- Standardized GNU's `__attribute__` and MSVC's `__declspec`
-  can be used almost everywhere in the C++ program, and can be applied to almost everything
-  each particular attribute is only valid where it is permitted by the implementation
-  Besides the standard attributes, implementations may support arbitrary non-standard attributes
-  All attributes unknown to an implementation are ignored

---

## Examples

- `[[noreturn]]`
- `[[deprecated("reason")]]` (C++14)
- `[[maybe_unused]]` (C++17)
- `[[likely]]` (C++20)
- `[[gnu::always_inline]]`

---

## time to benchmark

[raw vs. unique vs. shared](https://quick-bench.com/q/FrCYZD3FgKip5Kwn9Uz76RHM97A)

[with inlining](https://quick-bench.com/q/BOW6gJETy-bFADckH42l_vkjP3w)

[`make_shared` vs. `new`](https://quick-bench.com/q/3J4mZ3uN45kbDosFrpOsMN5BNsk)

---

## do work

```cpp [1-5|9-13]
struct ThreadPool
{
    template<typename F>
    void execute(F&&);
};

///hide
template<typename F>
void ThreadPool::execute(F&&) {}

///unhide
struct Work
{
    void execute() {
        m_pool.execute([this]{
            doWork();
        });
    }

void doWork();

ThreadPool m_pool;
};
```

Source: [nextptr](https://www.nextptr.com/tutorial/ta1414193955/enable_shared_from_this-overview-examples-and-internals)

Note: what if work is destroyed before the pool?

---

## do work

```cpp [12-15]
#include <memory>

struct ThreadPool
{
    template<typename F>
    void execute(F&&);
};

///hide
template<typename F>
void ThreadPool::execute(F&&) {}

///unhide
struct Work
{
    void execute() {
        auto self = std::shared_ptr<Work>(this);
        m_pool.execute([self]{
            self->doWork();
        });
    }

void doWork();

ThreadPool m_pool;
};
```

---

## do work

```cpp [6,17-18]
#include <memory>

///hide
struct ThreadPool
{
    template<typename F>
    void execute(F&&);
};

template<typename F>
void ThreadPool::execute(F&&) {}

///unhide
struct Work
{
    void execute() {
        auto self = std::shared_ptr<Work>(this);
        m_pool.execute([self]{
            self->doWork();
        });
    }

void doWork();

ThreadPool m_pool;
};

///hide
void Work::doWork() {}

int main() {
///unhide
auto work = std::make_shared<Work>();
work->doWork();
///hide
}
```

---

## `std::enable_shared_from_this`

```cpp [3,6]
#include <memory>

///hide
struct ThreadPool
{
    template<typename F>
    void execute(F&&);
};

template<typename F>
void ThreadPool::execute(F&&) {}

///unhide
struct Work : std::enable_shared_from_this<Work>
{
    void execute() {
        auto self = shared_from_this();
        m_pool.execute([self]{
            self->doWork();
        });
    }

void doWork();

ThreadPool m_pool;
};

///hide
void Work::doWork() {}

int main() {
///unhide
auto work = std::make_shared<Work>();
work->doWork();
///hide
}
```

---

## how to pass smart pointers

C++ Core Guidelines [R.32](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r32-take-a-unique_ptrwidget-parameter-to-express-that-a-function-assumes-ownership-of-a-widget): Take a `unique_ptr<widget>` parameter to express that a function assumes ownership of a widget

```cpp
///hide
#include <memory>

class widget;

///unhide
// takes ownership of the widget
void sink(std::unique_ptr<widget>);
```

---

## how to pass smart pointers

C++ Core Guidelines [R.33](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r33-take-a-unique_ptrwidget-parameter-to-express-that-a-function-reseats-thewidget): Take a `unique_ptr<widget>&` parameter to express that a function reseats the `widget`

```cpp
///hide
#include <memory>

class widget;

///unhide
// "will" or "might" reseat pointer
void reseat(std::unique_ptr<widget>&);
```

Note: Note "reseat" means "making a pointer or a smart pointer refer to a different object."

---

## how to pass smart pointers

C++ Core Guidelines [R.34](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r34-take-a-shared_ptrwidget-parameter-to-express-that-a-function-is-part-owner): Take a `shared_ptr<widget>` parameter to express that a function is part owner

```cpp
///hide
#include <memory>

class widget;

///unhide
// share -- "will" retain refcount
void share(std::shared_ptr<widget>);
```

---

## how to pass smart pointers

C++ Core Guidelines [R.35](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r35-take-a-shared_ptrwidget-parameter-to-express-that-a-function-might-reseat-the-shared-pointer): Take a `shared_ptr<widget>&` parameter to express that a function might reseat the shared pointer

```cpp
///hide
#include <memory>

class widget;

///unhide
// "might" reseat ptr
void reseat(std::shared_ptr<widget>&);
```

---

## how to pass smart pointers

C++ Core Guidelines [R.36](http://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#r32-take-a-unique_ptrwidget-parameter-to-express-that-a-function-assumes-ownership-of-a-widget): Take a `const shared_ptr<widget>&` parameter to express that it might retain a reference count to the object

```cpp
///hide
#include <memory>

class widget;

///unhide
// "might" retain refcount
void may_share(const std::shared_ptr<widget>&);
```

---

----

---

## how much time

```cpp
///hide
void sleep(int);

void foo() {
///unhide
sleep(10);
///hide
}
```

Need to check [documentation](https://man7.org/linux/man-pages/man3/sleep.3.html)

---

Source: [CppCon 2016: Howard Hinnant "A `＜chrono＞` Tutorial"](https://www.youtube.com/watch?v=P32hvk8b13M)

</div>

# `std::chrono`

---

## `std::chrono::seconds`

Scalar-like construction behavior

```cpp
#include <chrono>
///hide
void foo() {
{
///unhide
std::chrono::seconds s; // no initialization
///hide
}
{
///unhide
std::chrono::seconds s{}; // zero initialization
///hide
}
}
```

---

## `std::chrono::seconds`

no implicit conversion from int

```cpp
///fails=conversion from 'int' to non-scalar type 'std::chrono::seconds'
#include <chrono>
///hide
void foo() {
{
///unhide
std::chrono::seconds s = 3; // fails
///hide
}
{
///unhide
std::chrono::seconds s{3}; // good
///hide
}
}
```

---

## new integer types

Exact-width integer types

- `int8_t`
- `int16_t`
- `int32_t`
- `int64_t`
- `uint8_t`
- `uint16_t`
- `uint32_t`
- `uint64_t`

</div>

Note: `(u)intN_t` designates a (un)signed integer type with width N, no padding
bits, and a two’s complement representation.

---

## new integer types

Minimum-width integer types

- `int_least8_t`
- `int_least16_t`
- `int_least32_t`
- `int_least64_t`
- `uint_least8_t`
- `uint_least16_t`
- `uint_least32_t`
- `uint_least64_t`

</div>

Note: `(u)int_leastN_t` designates a (un)signed integer type with a width of at least N,  such that no signed integer type with lesser size has at least the specified width.

---

## new integer types

Fastest minimum-width integer types

- `int_fast8_t`
- `int_fast16_t`
- `int_fast32_t`
- `int_fast64_t`
- `uint_fast8_t`
- `uint_fast16_t`
- `uint_fast32_t`
- `uint_fast64_t`

</div>

Note: `(u)int_fastN_t` designates the fastest (un)signed integer type with a width of at fast N.

---

## new integer types

Integer types capable of holding object pointers

- `intptr_t`
- `uintptr_t`

</div>

Note: `(u)intptr_t` designates a (un)signed integer type with the property that any valid
pointer to `void` can be converted to this type, then converted back to pointer to `void`,
and the result will compare equal to the original pointer.

---

## new integer types

Greatest-width integer types

- `intmax_t`
- `uintmax_t`

</div>

Note: `(u)intmax_t` designates a (un)signed integer type capable of representing any value of
any (un)signed integer type.

---

## `std::chrono::seconds`

no implicit conversion to int

```cpp
///fails=cannot convert 'std::chrono::seconds'
#include <chrono>
///hide
void foo() {
{
///unhide
int64_t s = std::chrono::seconds{3}; // fails
///hide
}
{
///unhide
int64_t s = std::chrono::seconds{3}.count(); // good
///hide
}
}
```

---

## `std::chrono::seconds`

Addition and subtraction

```cpp
#include <chrono>

using std::chrono::seconds;

void f(seconds d);

///hide
void foo() {
///unhide
seconds x{3};
x += seconds{3};
f(x); // f(5 seconds)
x = x - seconds{1};
f(x); // f(4 seconds)
// f(x + 1); // error: seconds + int not allowed
///hide
}
```

---

## `std::chrono::seconds`

comparison

```cpp
///hide
#include <chrono>
#include <iostream>

///unhide
using std::chrono::seconds;

const auto time_limit = seconds{2};

void f(seconds d)
{
  if (d <= time_limit)
    std::cout << "in time: ";
  else
    std::cout << "out of time: ";
  std::cout << d.count() << "s\n";
}
```

---

## `std::chrono::seconds`

comparison

```cpp
///fails=no match for 'operator<='
///hide
#include <chrono>
#include <iostream>

///unhide
using std::chrono::seconds;

const auto time_limit = 2;

void f(seconds d)
{
  if (d <= time_limit) // error: seconds <= int not allowed
    std::cout << "in time: ";
  else
    std::cout << "out of time: ";
  std::cout << d.count() << "s\n";
}
```

---

## `std::chrono::seconds`

range of ±292 billion years

```cpp
///hide
#include <chrono>
#include <iostream>

///unhide
using std::chrono::seconds;

int main() {
  const auto secondsInAYear = 60 * 60 * 24 * 365;
  std::cout
   << seconds::max().count() / secondsInAYear << '\n'
   << seconds::min().count() / secondsInAYear << '\n'; 
}
```

---

## `std::chrono::seconds`

[How much does it cost?!](https://quick-bench.com/q/2Ff1rtmFfBcm--J0RpTYpWbbCW0)

---

## literals

```cpp
auto a{42}, b{052}, c{0x2A};  // integer, int
auto d{4.27}, e{5E1};         // floating point, double
auto f{'f'}, g{'\n'};         // character, char
auto h = "foo";               // string, const char[4]
auto i{true}, k{false};       // boolean, bool
```

Source: [SIMPLIFY C++](https://arne-mertz.de/2016/10/modern-c-features-user-defined-literals/)

</div>

---

## new character types and literals

```cpp
///hide
#include <iostream>

int main() {
///unhide
char const utf8[]{u8"Hello, ☃!"};
char16_t const utf16[]{u"Hello, ☃!"};
char32_t const utf32[]{U"Hello, ☃!"};

std::cout 
  << "sizeof(utf8) = " << sizeof(utf8) << '\n'
  << "sizeof(utf16) = " << sizeof(utf16) << '\n'
  << "sizeof(utf32) = " << sizeof(utf32) << '\n';
///hide
}
```

from C++20:

```cpp
///compiler=g93
///options=-std=c++2a
char8_t const utf8[]{u8"Hello, ☃!"};
```

Note: char8_t was introduced to enable overloading between char and char8_t

---

## literal suffixes

```cpp
auto a{32u};     // unsigned int
auto b{043l};    // long
auto c{0x34ull}; // unsigned long long
auto d{4.27f};   // float
auto e{5E1l};    // long double
```

---

## user-defined literals

```cpp []
///hide
#include <cmath>
#include <cassert>

///unhide
const auto PI = 3.14159265358979323846264L;

long double operator""_deg ( long double deg )
{
    return deg * PI / 180;
}

///hide
int main() {
///unhide
assert(std::sin(90.0_deg) == 1);
///hide
}
```

---

## user-defined literals

alternatively

```cpp []
///hide
#include <cmath>
#include <cassert>
#include <string>

///unhide
const auto PI = 3.14159265358979323846264L;

long double operator""_deg ( const char* deg )
{
    return std::stold(deg) * PI / 180;
}

///hide
int main() {
///unhide
assert(std::sin(90.0_deg) == 1);
///hide
}
```

---

## user-defined literals

also takes integrals

```cpp []
///hide
#include <cmath>
#include <cassert>
#include <string>

///unhide
const auto PI = 3.14159265358979323846264L;

long double operator""_deg ( const char* deg )
{
    return std::stold(deg) * PI / 180;
}

///hide
int main() {
///unhide
assert(std::sin(90_deg) == 1);
///hide
}
```

---

## allowed parameters

user-defined integer literals

```cpp
///hide
struct T {};

///unhide
T operator""_suffix ( unsigned long long int );

T x = 42_suffix;
```

---

## allowed parameters

user-defined floating-point literals

```cpp
///hide
struct T {};

///unhide
T operator""_suffix ( long double );

T x = 42.0_suffix;
```

---

## allowed parameters

raw literal operators

```cpp
///hide
struct T {};

///unhide
T operator""_suffix ( const char* );

T x = 42_suffix;

T y = 42.0_suffix;
```

used as fallbacks for integer and floating-point user-defined literals

---

## allowed parameters

user-defined character literals

```cpp
///compiler=g93
///options=-std=c++2a
///hide
struct T {};

///unhide
T operator""_suffix ( char );
T operator""_suffix ( wchar_t );
T operator""_suffix ( char8_t ); // C++20
T operator""_suffix ( char16_t );
T operator""_suffix ( char32_t );

T x = u'4'_suffix;
```

---

## allowed parameters

user-defined string literals

```cpp
///compiler=g93
///options=-std=c++2a
///hide
#include <cstdint>

struct T {};

///unhide
T operator""_suffix ( const char     * , std::size_t );
T operator""_suffix ( const wchar_t  * , std::size_t );
T operator""_suffix ( const char8_t  * , std::size_t ); // C++20
T operator""_suffix ( const char16_t * , std::size_t );
T operator""_suffix ( const char32_t * , std::size_t );

T x = U"42"_suffix;
```

---

## Library string literals (C++14)

String literals

```cpp
#include <string>
///hide
#include <iostream>
///unhide

///hide
int main()
{
///unhide
using namespace std::string_literals;
// or using namespace std::literals;

const std::string s1 = "abc\0def";
const std::string s2 = "abc\0def"s;
std::cout << "s1: " << s1.size() << " \"" << s1 << "\"\n";
std::cout << "s2: " << s2.size() << " \"" << s2 << "\"\n";
///hide
}
```

---

## Library string literals (C++14)

Complex literals

```cpp
#include <complex>
///hide
#include <iostream>
///unhide

///hide
int main()
{
///unhide
using namespace std::complex_literals;
// or using namespace std::literals;

const auto c = 1.0 + 1i;
std::cout << "abs" << c << " = " << abs(c) << '\n';
///hide
}
```

---

## Library string literals (C++14)

`chrono` literals

```cpp
#include <chrono>
///hide
#include <iostream>
///unhide

///hide
int main()
{
///unhide
using namespace std::chrono_literals;
// or using namespace std::literals;

auto halfmin = 30s;
std::cout 
  << "half a minute is " << halfmin.count() << " seconds\n";
///hide
}
```

---

Source: [The C++ Standard Library: A Tutorial and Reference, Nicolai Josuttis](http://www.cppstdlib.com/)

</div>

## `std::ratio`

---

## compile-time rational number

```cpp
///hide
#include <iostream>
///unhide
#include <ratio>

///hide
int main()
{
///unhide
using FiveThirds = std::ratio<5,3>;
std::cout << FiveThirds::num << "/" << FiveThirds::den << '\n';

using AlsoFiveThirds = std::ratio<25,15>;
std::cout << AlsoFiveThirds::num << "/" << AlsoFiveThirds::den << '\n';

using one = std::ratio<42,42>;
std::cout << one::num << "/" << one::den << '\n';

using zero = std::ratio<0>;
std::cout << zero::num << "/" << zero::den << '\n';

using Neg = std::ratio<7,-3>;
std::cout << Neg::num << "/" << Neg::den << '\n';
///hide
}
```

---

## compile-time rational arithmetic

```cpp
///hide
#include <ratio>

///unhide
static_assert(
  std::ratio_equal<
    std::ratio_add<
      std::ratio<1,4>, 
      std::ratio<2,3>
    >::type,
    std::ratio_multiply<
      std::ratio<1, 3>, 
      std::ratio<11, 4>
    >::type
  >::value,
  "rationals FTW"
);
```

---

## compile-time error checks

```cpp
///fails=static assertion failed: overflow in multiplication
///hide
#include <ratio>
#include <limits>

///unhide
std::ratio_multiply<
    std::ratio<1, std::numeric_limits<intmax_t>::max()>,
    std::ratio<1, 2>
>::type; // error: overflow in multiplication

std::ratio_divide<
    std::ratio<1, 2>,
    std::ratio<0>
>::type; // error: denominator cannot be zero
```

---

## predefined ratios

|name|value|name|value|
|----|-----|----|-----|
|`yocto`*|`std::ratio<1, 1000000000000000000000000>`|`deca`|`std::ratio<10, 1>`|
|`zepto`*|`std::ratio<1, 1000000000000000000000>`|`hecto`|`std::ratio<100, 1>`|
|`atto`|`std::ratio<1, 1000000000000000000>`|`kilo`|`std::ratio<1000, 1>`|
|`femto`|`std::ratio<1, 1000000000000000>`|`mega`|`std::ratio<1000000, 1>`|
|`pico`|`std::ratio<1, 1000000000000>`|`giga`|`std::ratio<1000000000, 1>`|
|`nano`|`std::ratio<1, 1000000000>`|`tera`|`std::ratio<1000000000000, 1>`|
|`micro`|`std::ratio<1, 1000000>`|`peta`|`std::ratio<1000000000000000, 1>`|
|`milli`|`std::ratio<1, 1000>`|`exa`|`std::ratio<1000000000000000000, 1>`|
|`centi`|`std::ratio<1, 100>`|`zetta`*|`std::ratio<1000000000000000000000, 1>`|
|`deci`|`std::ratio<1, 10>`|`yotta`*|`std::ratio<1000000000000000000000000, 1>`|

`*` if `std::intmax_t` can represent the denominator

---

## `std::chrono::duration`

```cpp
///hide
#include <ratio>

///unhide
template<
  class Rep,
  class Period = std::ratio<1>
> class duration;
```

---

## predefined durations

|name|literal|value|
|----|-------|-----|
|`std::chrono::nanoseconds`|`ns`|`duration<int_least64_t, std::nano>`|
|`std::chrono::microseconds`|`us`|`duration<int_least55_t, std::micro>`|
|`std::chrono::milliseconds`|`ms`|`duration<int_least45_t, std::milli>`|
|`std::chrono::seconds`|`s`|`duration<int_least35_t>`|
|`std::chrono::minutes`|`min`|`duration<int_least29_t, std::ratio<60>>`|
|`std::chrono::hours`|`h`|`duration<int_least23_t, std::ratio<3600>>`|

`*` some types can use smaller integers

---

## conversions

lossless conversions are implicit

```cpp
///hide
#include <chrono>

///unhide
using namespace std::chrono_literals;

std::chrono::milliseconds m = 3s; // 3000ms
std::chrono::nanoseconds n = 5h;  // 18000000000000ns
```

---

## conversions

lossy conversions require `duration_cast` (truncates towards zero)

```cpp
///hide
#include <chrono>

///unhide
using namespace std::chrono_literals;
using namespace std::chrono;

auto s = duration_cast<seconds>(3400ms); // 3s
```

---

## more conversions (C++17)

```cpp
///options=-std=c++17
///hide
#include <chrono>
#include <iostream>

int main() {
///unhide
using namespace std::chrono;

std::cout << floor<seconds>(3600ms).count() << '\n';
std::cout << ceil<seconds>(3400ms).count() << '\n';
std::cout << round<seconds>(3600ms).count() << '\n';
std::cout << round<seconds>(3400ms).count() << '\n';
///hide
}
```

Note: Only use an explicit cast when an implicit
conversion won't work.
If the implicit conversion compiles, it will be exact.
Otherwise it won't compile and you can make the
decision of which rounding mode you need

---

## mixed arithmetics

like rational arithmetic

```cpp
///hide
#include <chrono>
#include <cassert>

int main() {
///unhide
using namespace std::chrono_literals;

assert(30ms - 1100us == 28900us);
assert(500ms + 2500000us == 3s);
///hide
}
```

---

## custom representations

users can use any arithmetics type as the underlying representations

```cpp
///hide
#include <chrono>
#include <iostream>

int main() {
using namespace std::chrono_literals;
///unhide
using seconds32 = std::chrono::duration<uint32_t>;
using fseconds = std::chrono::duration<float>;

fseconds f = 45ms;
std::cout << f.count() << "s\n"; // 0.045s
///hide
}
```

Note: `duration_cast` is not needed on floating point representation.

---

## custom durations

```cpp
///hide
#include <chrono>
#include <iostream>

int main() {
///unhide
using namespace std;

using frames = chrono::duration<int32_t, ratio<1, 60>>;
using fmillis = chrono::duration<float, milli>;

fmillis f = 45ms + frames{5};
std::cout << f.count() << "ms\n"; // 128.333ms
///hide
}
```

---

## `time points and clocks`

---

## `std::chrono::time_point`

A specific point in time, with respect to some clock, which has a precision of some duration

```cpp
template <
  class Clock, 
  class Duration = typename Clock::duration
> class time_point;
```

---

## clock

a bundle of a duration, a time_point and a static function to get the current time.

```cpp
///hide
#include <chrono>

namespace chrono = std::chrono;

///unhide
struct some_clock
{
  using duration = chrono::duration<int64_t, std::micro>;
  using rep = duration::rep;
  using period = duration::period;
  using time_point = chrono::time_point<some_clock>;

static constexpr bool is_steady = false;

static time_point now() noexcept;
};
```

---

## standard clocks

- `std::chrono::system_clock` for wall-clock time (what time of day is it?)
- `std::chrono::steady_clock` for duration measurements

---

## duration vs. time point

`10000s` means **any** 10,000 seconds, but

```cpp
///hide
#include <chrono>

void foo() {
namespace chrono = std::chrono;
using namespace std::chrono_literals;
///unhide
chrono::time_point<chrono::system_clock, chrono::seconds>{10000s};
///hide
}
```

means

1970-01-01 02:46:40 UTC

---

## time point conversions

lossless is implicit, lossy with `time_point_cast`

```cpp
///hide
#include <chrono>

using namespace std::chrono_literals;
///unhide
using namespace std::chrono;
template <class D>
using sys_time = time_point<system_clock, D>;

sys_time<milliseconds> tpm = sys_time<seconds>{5s};
sys_time<seconds> tps = time_point_cast<seconds>(tpm);
```

time_points associated with different clocks
**do not** convert to one another.

---

## time point arithmetic

subtracting two time points yields a duration

```cpp
///hide
#include <chrono>
#include <iostream>

int main() {
using namespace std::chrono;
using namespace std::chrono_literals;
///unhide
const auto start = steady_clock::now();
system_clock::now();
const auto end = steady_clock::now();
auto d = duration_cast<microseconds>(end - start);
std::cout 
  << "getting time of day took " 
  << d.count() << "us\n";
///hide
}
```

---

----

---

## enum safety

```cpp
///fails=Assertion `isRed(CndRed)' failed
///hide
#include <cassert>

///unhide
enum Color { ClrRed, ClrOrange, ClrYellow, ClrGreen };
enum Alert { CndGreen, CndYellow, CndRed };

bool isRed(Alert alert) {
    return alert == ClrRed;
}

int main(){
    assert(isRed(CndRed)); // oops
}
```

Source: [N2347](https://wg21.link/n2347)

</div>

---

## enum safety

```cpp []
///options=--short-enums
///fails=static assertion failed
enum Version { Ver1 = 1, Ver2 = 2 };

struct Packet {
 Version ver; // bad, size can vary by implementation
 // … more data …
 Version getVersion() const { return ver; }
};

static_assert(sizeof(Packet) == sizeof(int), "");
```

---

## scoped enums

```cpp
///hide
#include <cassert>

///unhide
enum class Color { Red, Orange, Yellow, Green };
enum class Alert { Green, Yellow, Red };

bool isRed(Alert alert) {
  // return alert == Color::Red; // doesn't compile
  return alert == Alert::Red;
}

int main(){
  assert(isRed(Alert::Red));
}
```

---

## sized enums

```cpp [1,9]
///options=--short-enums
enum Version : int { Ver1 = 1, Ver2 = 2 };

struct Packet {
 Version ver; // bad, size can vary by implementation
 // … more data …
 Version getVersion() const { return ver; }
};

static_assert(sizeof(Packet) == sizeof(int), "");
```

---

C++ Core Guidelines [Enum.3](https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#enum3-prefer-class-enums-over-plain-enums): Prefer class enums over "plain" enums

---

## let's fly

![flights](08_error_handling/flights.svg)

Source: [Andrzej's C++ blog](https://akrzemi1.wordpress.com/2017/09/04/using-error-codes-effectively/)

</div>

---

## different error codes

```cpp
enum class Flights0Errc
{
  // no 0
  NonexistentLocations = 10,
  DatesInThePast,
  InvertedDates,
  NoFlightsFound       = 20,
  ProtocolViolation    = 30,
  ConnectionError,
  ResourceError,
  Timeout,
};

enum class Flights1Errc
{
  // no 0
  ZeroFlightsFound     = 11,
  InvalidRequestFormat = 12,
  CouldNotConnect      = 13,
  DatabaseError        = 14,
  NotEnoughMemory      = 15,
  InternalError        = 16,
  NoSuchAirport        = 17,
  JourneyInThePast     = 18,
  DatesNotMonotonic    = 19,
};

enum class SeatsErrc
{
  // no 0
  InvalidRequest = 1,
  CouldNotConnect,
  InternalError,
  NoResponse,
  NonexistentClass,
  NoSeatAvailable,
};

```

---

## error source

1. User sent us an illogical request.
2. There is some problem with the system which the user will not understand but which prevents us from returning the requested answer.
3. No airline we are aware of is able to offer a requested trip.

---

## error severity

1. A bug.
2. An incorrect configuration.
3. A (perhaps temporary) shortage of resources.
4. Normal (like “no solutions found”) — user may be disappointed, but developers or the system did nothing wrong.

---

# error handling

---

## `std::error_category`

A base class for error domains.

```cpp
///hide
#include <string>

///unhide
namespace std {
  class error_category {
  public:
    virtual const char* name() const noexcept = 0;
    virtual string message(int ev) const = 0;
    // other functions
  };
}
```

---

## defining a category

```cpp [1,3-4,18,21|4-7|9-17|20]
#include <system_error>
///hide
enum class Flights0Errc
{
  // no 0
  NonexistentLocations = 10,
  DatesInThePast,
  InvertedDates,
  NoFlightsFound       = 20,
  ProtocolViolation    = 30,
  ConnectionError,
  ResourceError,
  Timeout,
};
///unhide
 
namespace {
struct Flights0ErrCategory : std::error_category {
  const char* name() const noexcept override {
    return "flights0";
  }

std::string message(int ev) const override {
    switch (static_cast<Flights0Errc>(ev))
    {
    case Flights0Errc::NonexistentLocations: return "nonexistent airport name in request";
    case Flights0Errc::DatesInThePast: return "request for a date from the past";
    /// etc.
    default: return "(unrecognized error)";
    }
  }
};
 
const Flights0ErrCategory flights0ErrCategory;
} // namespace
```

`flights0.cpp`

---

## `std::error_code`

Error number and category.

```cpp [2,4,11-12|13-14|5-10]
///hide
#include <type_traits>
#include <string>

namespace std {
template<typename>
struct is_error_code_enum : std::false_type {};
}

class error_category;

///unhide
namespace std {
  class error_code {
  public:
    error_code(int val, const error_category& cat) noexcept;
    template<class ErrorCodeEnum, 
             typename = std::enable_if_t<
                          std::is_error_code_enum<
                            ErrorCodeEnum
                          >::value>>
      error_code(ErrorCodeEnum e) noexcept;
    int value() const noexcept;
    const error_category& category() const noexcept;
    string message() const;
    explicit operator bool() const noexcept;
    // other members
  };
}
```

Note: `operator bool()` returns `value() != 0`

---

## defining an error code

```cpp [1|3-14|16-22|24]
# include <system_error>

enum class Flights0Errc
{
  // no 0
  NonexistentLocations = 10,
  DatesInThePast,
  InvertedDates,
  NoFlightsFound       = 20,
  ProtocolViolation    = 30,
  ConnectionError,
  ResourceError,
  Timeout,
};

namespace std
{
  template <>
  struct is_error_code_enum<Flights0Errc> 
    : true_type 
  {};
}

std::error_code make_error_code(Flights0Errc);
```

```cpp [0|0|0|1-4]
///hide
#include <system_error>

namespace std
{
  template <> struct 
  is_error_code_enum<Flights0Errc> 
  : true_type {};
}

struct Flights0ErrCategory : std::error_category {
  const char* name() const noexcept override {
    return "flights0";
  }

std::string message(int ev) const override {
    return {};
  }

};
const Flights0ErrCategory flights0ErrCategory;

///unhide
std::error_code make_error_code(Flights0Errc e) {
  return {static_cast<int>(e), 
          flights0ErrCategory};
}
```

`flights0.hpp`

`flights0.cpp`

</div>

Note: similarly for `Flights1Errc` and `SeatsErrc`

---

## using `std::error_code`

```cpp 
///hide
#include <system_error>
#include <iostream>
#include <cassert>

namespace std
{
  template <> struct 
  is_error_code_enum<Flights0Errc> 
  : true_type {};
}

namespace {
struct Flights0ErrCategory : std::error_category {
  const char* name() const noexcept override {
    return "flights0";
  }

std::error_code make_error_code(Flights0Errc e) {
  return {static_cast<int>(e), 
          flights0ErrCategory};
}

#if 0
///unhide
#include "flights0.hpp"
///hide
#endif
///unhide

int main()
{
  std::error_code ec = Flights0Errc::DatesInThePast;
  std::cout << ec << ": " << ec.message() << '\n';
  assert(ec == Flights0Errc::DatesInThePast);
  assert(ec != Flights0Errc::InvertedDates);
}
```

---

## combining system errors

```cpp
enum class SubsystemError
{
    // no 0
    InputBadAirport = 1,
    InputPastDate,
    InputBadDateRange,
    InputBadClass,
    NoFlightFound,
    NoSeatFound,
    SubsysProtocolErr,
    SubsysInternal,
    SubsysResource,
    SubsysConfig,
    SubsysTimeout,
};
```

---

## `std::error_condition`

```cpp
///hide
#include <type_traits>
#include <string>

namespace std {
template<typename>
struct is_error_condition_enum : std::false_type {};
}

class error_category;

///unhide
namespace std {
  class error_condition {
  public:
    error_condition(int val, const error_category& cat) noexcept;
    template<class ErrorConditionEnum, 
             typename = std::enable_if_t<
                          std::is_error_condition_enum<
                            ErrorConditionEnum
                          >::value>>
      error_condition(ErrorConditionEnum e) noexcept;
    int value() const noexcept;
    const error_category& category() const noexcept;
    std::string message() const;
    explicit operator bool() const noexcept;
    // other members
  };
}
```

---

## what's the difference?

- **`error_code`** is used for storing and transmitting error codes as they were produced by originating library, unchanged;
- **`error_condition`** is used for performing queries on `error_code`s, for the purpose of grouping or classification or translation.

---

### using `std::error_condition`

```cpp []
# include <system_error>
 
enum class SubsystemError
{
    // no 0
    InputBadAirport = 1,
    InputPastDate,
    InputBadDateRange,
    InputBadClass,
    NoFlightFound,
    NoSeatFound,
    SubsysProtocolErr,
    SubsysInternal,
    SubsysResource,
    SubsysConfig,
    SubsysTimeout,
};

namespace std
{
  template <>
  struct is_error_condition_enum<SubsystemError> 
  : true_type {};
}
  
std::error_condition make_error_condition
  (SubsystemError e);
```

```cpp []
///hide
# include <system_error>
 
enum class SubsystemError
{
    // no 0
    InputBadAirport = 1,
    InputPastDate,
    InputBadDateRange,
    InputBadClass,
    NoFlightFound,
    NoSeatFound,
    SubsysProtocolErr,
    SubsysInternal,
    SubsysResource,
    SubsysConfig,
    SubsysTimeout,
};

namespace std
{
  template <>
  struct is_error_condition_enum<SubsystemError> 
  : true_type {};
}
#if 0
///unhide
#include "subsystem.hpp"
///hide
#endif
///unhide

namespace {
 
class SubsystemErrorCategory 
  : public std::error_category {
public:
  const char* name() const noexcept override {
    return "submodule-error";
  }
  std::string message(int ev) const override {
    switch (static_cast<SubsystemError>(ev)) {
      /// all messages
      default: return "(uncharted)";
    }
  }
};
 
const SubsystemErrorCategory 
  theSubsystemErrorCategory {};
  
}

std::error_condition make_error_condition
  (SubsystemError e) {
  return {static_cast<int>(e), 
          theSubsystemErrorCategory};
}
```

`subsystem.hpp`

`subsystem.cpp`

</div>

---

## mapping `error_code` to `error_condition`

```cpp [3,6-20]
///hide
#include <system_error>
#include <cassert>
#include <iostream>

namespace std
{
  template <> struct 
  is_error_code_enum<Flights0Errc> 
  : true_type {};
}

enum class SubsystemError
{
    // no 0
    InputBadAirport = 1,
    InputPastDate,
    InputBadDateRange,
    InputBadClass,
    NoFlightFound,
    NoSeatFound,
    SubsysProtocolErr,
    SubsysInternal,
    SubsysResource,
    SubsysConfig,
    SubsysTimeout,
};

namespace std
{
  template <>
  struct is_error_condition_enum<SubsystemError> 
  : true_type {};
}
  
std::error_condition make_error_condition
  (SubsystemError e);
///unhide
namespace {

struct Flights0ErrCategory : std::error_category {
  const char* name() const noexcept override;
  std::string message(int ev) const override;
  std::error_condition default_error_condition(int ev)
    const noexcept override {
    switch (static_cast<Flights0Errc>(ev))
    {
    case Flights0Errc::NonexistentLocations: return SubsystemError::InputBadAirport;
    case Flights0Errc::DatesInThePast: return SubsystemError::InputPastDate;
    case Flights0Errc::InvertedDates: return SubsystemError::InputBadDateRange;
    case Flights0Errc::NoFlightsFound: return SubsystemError::NoFlightFound;
    case Flights0Errc::ProtocolViolation: return SubsystemError::SubsysProtocolErr;
    case Flights0Errc::ConnectionError: return SubsystemError::SubsysConfig;
    case Flights0Errc::ResourceError: return SubsystemError::SubsysResource;
    case Flights0Errc::Timeout: return SubsystemError::SubsysTimeout;
    default: assert (false); return {};
    }
  }
};
 
}
```

`flights0.cpp`

Note: similarly for `Flights1Errc` and `SeatsErrc`

---

## low level query

```cpp
///hide
#include <system_error>
#include <iostream>

namespace std
{
  template <> struct 
  is_error_code_enum<Flights0Errc> 
  : true_type {};
}

std::error_code make_error_code(Flights0Errc);

enum class SeatsErrc
{
  // no 0
  InvalidRequest = 1,
  CouldNotConnect,
  InternalError,
  NoResponse,
  NonexistentClass,
  NoSeatAvailable,
};

namespace std
{
  template <> struct 
  is_error_code_enum<SeatsErrc> 
  : true_type {};
}

std::error_code make_error_code(SeatsErrc);

namespace std
{
  template <>
  struct is_error_condition_enum<SubsystemError> 
  : true_type {};
}
  
std::error_condition make_error_condition
  (SubsystemError e);

///unhide
void handle_error(std::error_code ec) {
  if (ec == SubsystemError::InputPastDate) {
      std::cerr << "please entry future date\n";
  } else if (ec == SubsystemError::InputBadDateRange) {
      std::cerr << "return date is before departure\n";
  }
  /// handle other cases 
}

///hide
void foo() {
///unhide
handle_error(Flights0Errc::DatesInThePast);
handle_error(SeatsErrc::NonexistentClass);
///hide
}
```

---

## how does this work

```cpp
///hide
#include <system_error>

using namespace std;

///unhide
bool operator==(const error_code& lhs, 
                const error_condition& rhs) noexcept {
  return lhs.category().equivalent(lhs.value(), rhs) ||
         rhs.category().equivalent(lhs, rhs.value());
}

class error_category {
///hide
  std::error_condition default_error_condition(int ev) const;

bool operator==( const std::error_category& rhs ) const noexcept;

///unhide
  virtual bool equivalent(int code, 
                          const error_condition& cond) 
                          const noexcept {
    return default_error_condition(code) == cond;
  }

virtual bool equivalent(const error_code& code, 
                          int cond) 
                          const noexcept {
    return *this == code.category() && code.value() == cond;
  }
};
```

---

## going to a higher level

```cpp []
#include <system_error>

enum class FailureSource
{
  // no 0
  BadUserInput = 1,
  SystemError,
  NoSolution,

};
  
namespace std
{
  template <>
  struct is_error_condition_enum<FailureSource> 
  : true_type {};
}
  
std::error_condition make_error_condition
  (FailureSource e);
```

```cpp []
#include <system_error>

enum class Severity
{
  // no 0
  Bug = 1,
  Config,
  Resource,
  Normal,
};
  
namespace std
{
  template <>
  struct is_error_condition_enum<Severity> 
  : true_type {};
}
  
std::error_condition make_error_condition
  (Severity e);
```

`failure_source.hpp`

`severity.hpp`

</div>

---

## mapping low to high

```cpp
///hide
#include <system_error>

namespace std
{
  template <>
  struct is_error_condition_enum<SubsystemError> 
  : true_type {};
}
  
std::error_condition make_error_condition
  (SubsystemError e);

///unhide
class SeverityCategory : public std::error_category {
public:
  bool equivalent(const std::error_code& ec, int cond) const noexcept override {     
    switch (static_cast<Severity>(cond)) {
    case Severity::Bug: return ec == SubsystemError::SubsysProtocolErr
                            || ec == SubsystemError::SubsysInternal;
          
    case Severity::Config: return ec == SubsystemError::SubsysConfig;
  
    case Severity::Resource: return ec == SubsystemError::SubsysResource        
                                 || ec == SubsystemError::SubsysTimeout;
          
    case Severity::Normal: return ec == SubsystemError::InputBadAirport
                               || ec == SubsystemError::InputPastDate
                               || ec == SubsystemError::InputBadDateRange
                               || ec == SubsystemError::InputBadClass
                               || ec == SubsystemError::NoFlightFound
                               || ec == SubsystemError::NoSeatFound;
                
    default: return false;
    }
  }
};
```

`severity.cpp`

---

## high level query

```cpp
///hide
#include <system_error>
#include <cassert>
#include <iostream>

namespace std
{
  template <> struct 
  is_error_code_enum<Flights0Errc> 
  : true_type {};
}

std::error_code make_error_code(Flights0Errc);

namespace std
{
  template <>
  struct is_error_condition_enum<SubsystemError> 
  : true_type {};
}

///unhide
void handle_error(std::error_code ec) {
  if (ec == Severity::Bug) {
      assert(false);
      std::cerr << "BUG BUG BUG\n";
  } else if (ec == Severity::Config) {
      std::cerr << "configuration error: " << ec << "\n";
  } else if (ec == Severity::Resource) {
      std::cout << "Please try again in a few minutes\n";
  } else {
    assert(ec == Severity::Normal);
  }
}

///hide
void foo() {
///unhide
handle_error(Flights0Errc::DatesInThePast);
///hide
}
```

---

# system agnostic failure handling

![error mapping](08_error_handling/error_mapping.svg)

- Adding an additional subsystem will only require mapping to `SubsystemError` without affecting the rest of the system. 
- Adding high level queries is easy.

---

## In the standard library

---

## `std::system_error`

Thrown by various library functions with an associated `std::error_code`.

```cpp
///hide
#include <iostream>
#include <fstream>
 
int main() {
///unhide
try {
  std::ifstream in;
  in.exceptions(std::ifstream::failbit);
  in.open("no such file");
} catch (const std::system_error& ex) {
  std::cerr << "got ec " << ex.code() 
            << ": " << ex.what() << '\n';
}
///hide
}
```

---

## OS `error_condition`

based on posix errors

```cpp []
///hide
#include <type_traits>
namespace std {
template<typename> struct is_error_condition_enum;
struct error_condition {
  error_condition(int, int);
};
int generic_error();
}

///unhide
namespace std {

enum class errc {
    broken_pipe,                        // EPIPE
    invalid_argument,                   // EINVAL
    operation_not_permitted,            // EPERM
    permission_denied,                  // EACCES
    /// etc.
};

template<> struct is_error_condition_enum<errc> : true_type {};

error_condition make_error_condition(errc e) noexcept {
  return {static_cast<int>(e), generic_error()};
}

}
```

---

## `std::system_category`

Should be used by library implementers to report OS errors.

```cpp
///external
///compiler=vcpp_v19_24_x64
///options=/O2
///hide
#include <Windows.h>
#include <string>
#include <system_error>

///unhide
std::string read_file(const char *path) {
  HANDLE file = CreateFileA(path, GENERIC_READ, FILE_SHARE_READ, nullptr,
                            OPEN_EXISTING, 0, nullptr);
  if (file == INVALID_HANDLE_VALUE) {
    throw std::system_error(GetLastError(), std::system_category());
  }

auto size = GetFileSize(file, nullptr);

std::string str;
  str.resize(size);

DWORD read = 0;
  if (!ReadFile(file, &str.front(), size, &read, nullptr)) {
    throw std::system_error(GetLastError(), std::system_category());
  }

return str;
}
```

---

## `std::excpetion_ptr`

A shared-ownership smart pointer that manages an exception object, and may be passed to another function, possibly on another thread.

---

## `std::excpetion_ptr`

```cpp [12-17|1-9,18]
///hide
#include <iostream>
#include <string>
#include <exception>
#include <stdexcept>

///unhide
void handle_eptr(std::exception_ptr eptr) { // passing by value is ok
  try {
    if (eptr) {
      std::rethrow_exception(eptr);
    }
  } catch(const std::exception& e) {
    std::cout << "Caught exception \"" << e.what() << "\"\n";
  }
}
 
int main() {
    std::exception_ptr eptr;
    try {
        std::string().at(1); // this generates an std::out_of_range
    } catch(...) {
        eptr = std::current_exception(); // capture
    }
    handle_eptr(eptr);
} // destructor for std::out_of_range called here, when the eptr is destructed
```

---

## thank you

----

---

Source: [C++ Concurrency in Action, Anthony Williams](https://www.manning.com/books/c-plus-plus-concurrency-in-action-second-edition)

</div>

# Concurrency

Note: Until C++11 came the standard didn't acknowledge the existence of multithreaded applications. But since then there were many additions to support concurrent programming.

---

## hello `std::thread`

```cpp
///compiler=clang600
///options=-pthread
#include <iostream>
#include <thread>

int main()
{
    std::thread t([]{
      std::cout<<"Hello Concurrent World\n";
    });
    t.join();
}
```

Note: forgetting to join with terminate the program

---

## on exception

```cpp [1-3,10-11,16-23]
///compiler=clang600
///options=-pthread
///hide
#include <iostream>
#include <thread>
#include <stdexcept>

///unhide
void can_throw() {
    throw std::runtime_error("error");
}

void foo()
{
    std::thread t([]{
      std::cout<<"Hello Concurrent World\n";
    });
    can_throw();
    t.join();
}

int main()
{
  try {
    foo();
  } catch (const std::exception& ex) {
    std::cerr 
      << "got exception: " 
      << ex.what() 
      << '\n';
  }
}

```

---

## catch that

```cpp [10-16]
///compiler=clang600
///options=-pthread
///hide
#include <iostream>
#include <thread>
#include <stdexcept>

///unhide
void can_throw() {
    throw std::runtime_error("error");
}

void foo()
{
    std::thread t([]{
      std::cout<<"Hello Concurrent World\n";
    });
    try {
      can_throw();
    } catch(...) {
      t.join();
      throw;
    }
    t.join();
}

int main()
{
  try {
    foo();
  } catch (const std::exception& ex) {
    std::cerr 
      << "got exception: " 
      << ex.what() 
      << '\n';
  }
}

```

---

## RAII style

```cpp
///hide
#include <thread>

///unhide
class thread_joiner
{
public:
    explicit thread_joiner(std::thread& thread)
      : m_thread{thread}
    {}
    ~thread_joiner()
    {
      if(m_thread.joinable())
      {
        m_thread.join();
      }
    }
private:
    std::thread& m_thread;
};
```

Note: checking `joinable()` is important because `join()` will fail if the thread had already been joined

---

## use joiner

```cpp [7-11]
///compiler=clang600
///options=-pthread
///hide
#include <iostream>
#include <thread>
#include <stdexcept>

class thread_joiner
{
public:
    explicit thread_joiner(std::thread& thread)
      : m_thread{thread}
    {}
    ~thread_joiner()
    {
      if(m_thread.joinable())
      {
        m_thread.join();
      }
    }
private:
    std::thread& m_thread;
};

///unhide
void can_throw() {
    throw std::runtime_error("error");
}

void foo()
{
    std::thread t([]{
      std::cout<<"Hello Concurrent World\n";
    });
    thread_joiner joiner{t};
    can_throw();
}

int main()
{
  try {
    foo();
  } catch (const std::exception& ex) {
    std::cerr 
      << "got exception: " 
      << ex.what() 
      << '\n';
  }
}

```

---

## document editor

![word tabs](09_concurrency/word_tabs.png)

Note: We run each document-editing window in its own thread. Opening a new document therefore requires starting a new thread. The thread handling the request isn’t going to care about waiting for that other thread to finish, because it’s working on an unrelated document, so this makes it a prime candidate for running a detached thread.

---

## `detach` and passing arguments

```cpp [1-4,12-17]
///hide
#include <string>
#include <thread>

///unhide
enum class user_command
{
  open_new_document
};

///hide
void open_document_and_display_gui(const std::string);
bool done_editing();
user_command get_user_input();
std::string get_filename_from_user();
void process_user_input(user_command);

///unhide
void edit_document(const std::string& filename)
{
    open_document_and_display_gui(filename);
    while(!done_editing())
    {
        const auto cmd = get_user_input();
        if(cmd == user_command::open_new_document)
        {
            const auto new_name = get_filename_from_user();
            std::thread t(edit_document, new_name);
            t.detach();
        }
        else
        {
            process_user_input(cmd);
        }
    }
}
```

---

## lvalue reference?

```cpp []
///fails=std::thread arguments must be invocable after conversion to rvalues
///hide
#include <thread>
#include <fstream>

///unhide
void readFile(int& i) {
  std::fstream f{"input.txt"};
  f >> i;
}

///hide
void use() {
///unhide
int i;
std::thread t{readFile, i};
t.join();
///hide
}
```

---

## `std::reference_wrapper`

a copyable, assignable reference

```cpp
///hide
#include <iostream>
///unhide
#include <functional>

///hide
int main() {
///unhide
int x = 10, y = 20;
std::reference_wrapper<int> ref = x;
// ref = 15; // doesn't compile
x = 15;
std::cout << ref << '\n'; // prints 15
ref = y; // now bound to y
int& yy = ref;
yy = 25;
std::cout << y << '\n'; // prints 25
///hide
}
```

---

## `std::ref`, `std::cref`

```cpp
///hide
#include <type_traits>
///unhide
#include <functional>

///hide
int main() {
///unhide
int x = 10;

auto xref = std::ref(x);
static_assert(std::is_same<decltype(xref), 
  std::reference_wrapper<int>>::value,
  "non const");

auto cxref = std::cref(x);
static_assert(std::is_same<decltype(cxref), 
  std::reference_wrapper<const int>>::value,
  "const");
///hide
}
```

---

## counting sort comparisons

```cpp
///hide
#include <algorithm>
#include <functional>
#include <iostream>
#include <numeric>
#include <vector>

///unhide
struct counting_less {
  template<typename T> 
  bool operator()(const T& x, const T& y) {
    ++count;
    return x < y;
  }

int count = 0;
};

///hide
int main() {
///unhide
std::vector<int> elements{5, 3, 7, 2, 0};
counting_less cl;
std::sort(elements.begin(), elements.end(), cl);
std::cout << cl.count << " comparisons in sort\n";
///hide
}
```

---

## back to `thread`

```cpp [7]
///hide
#include <thread>
#include <fstream>

///unhide
void readFile(int& i) {
  std::fstream f{"input.txt"};
  f >> i;
}

///hide
void use() {
///unhide
int i;
std::thread t{readFile, std::ref(i)};
t.join();
///hide
}
```

---

## generic iterator traversal

before:

```cpp
template<typename Iterator>
auto get_3rd_from(Iterator it) ->decltype(*it) {
  return *(++(++(++it)));
}
```

after:

```cpp
#include <iterator>

template<typename Iterator>
auto get_3rd_to_last(Iterator it) ->decltype(*it) {
  return *std::next(it, 3);
}
```

---

## owning `thread_joiner`

```cpp [4-5,14-17,19]
///hide
#include <thread>

///unhide
class thread_joiner
{
public:
    explicit thread_joiner(std::thread thread)
      : m_thread{std::move(thread)}
    {}
    ~thread_joiner() {
      if(m_thread.joinable())
      {
        m_thread.join();
      }
    }
    thread_joiner(const thread_joiner&) = delete;
    thread_joiner(thread_joiner&&) = default;
    thread_joiner& operator=(const thread_joiner&) = delete;
    thread_joiner& operator=(thread_joiner&&) = default;
private:
    std::thread m_thread;
};
```

---

## parallel accumulate

```cpp [1-2|3-4|6-10|12-16|19-23,28|24-27|30|33|37-40]
///compiler=clang600
///options=-pthread
///hide
#include <thread>
#include <numeric>
#include <algorithm>
#include <vector>
#include <iostream>

class thread_joiner
{
public:
    explicit thread_joiner(std::thread thread)
      : m_thread{std::move(thread)}
    {}
    ~thread_joiner()
    {
      if(m_thread.joinable())
      {
        m_thread.join();
      }
    }
    thread_joiner(const thread_joiner&) = delete;
    thread_joiner(thread_joiner&&) = default;
    thread_joiner& operator=(const thread_joiner&) = delete;
    thread_joiner& operator=(thread_joiner&&) = default;
private:
    std::thread m_thread;
};

///unhide
template <typename Iterator, typename T, size_t MIN_PER_THREAD = 25>
T parallel_accumulate(Iterator first, Iterator last, T init) {
  const auto length = std::distance(first, last);
  if (!length) return init;

const auto max_threads = (length + MIN_PER_THREAD - 1) / MIN_PER_THREAD;
  const auto hardware_threads = std::thread::hardware_concurrency();
  const auto num_threads =
      std::min<size_t>(hardware_threads != 0 ? hardware_threads : 2, 
                       max_threads);

const auto block_size = length / num_threads;
  std::vector<T> results(num_threads);
  const auto accumulator = [](Iterator first, Iterator last, T& result) {
      result = std::accumulate(first, last, 0);
  };

{
    std::vector<thread_joiner> threads;
    auto block_start = first;
    std::transform(results.begin(), std::prev(results.end()), 
                   std::back_inserter(threads), 
                   [&](T& result){
        const auto block_end = std::next(block_start, block_size);
        std::thread t{accumulator, block_start, block_end, std::ref(result)};
        block_start = block_end;
        return thread_joiner{std::move(t)};
    });

accumulator(block_start, last, results.back());
  }
  
  return std::accumulate(results.begin(), results.end(), init);
}

int main() {
    std::vector<int64_t> v(10000);
    std::iota(v.begin(), v.end(), 1);

std::cout << parallel_accumulate(v.begin(), v.end(), 0) << '\n';
}
```

---

## data sharing

Note: As opposed to multi-process program, it is much easier to share data between different threads but that of course opens the door to data races. Let's see what tools we have to address this issue.

---

## protecting with a `mutex`

```cpp [4,8,10,15,18]
///hide
#include <list>
#include <algorithm>
///unhide
#include <mutex>

std::list<int> some_list;
std::mutex some_mutex;

void add_to_list(int new_value)
{
    some_mutex.lock();
    some_list.push_back(new_value);
    some_mutex.unlock();
}

bool list_contains(int value_to_find)
{
    some_mutex.lock();
    return std::find(some_list.begin(), some_list.end(), value_to_find)
        != some_list.end();
    some_mutex.unlock();
}
```

---

## RAII with a `lock_guard`

```cpp [4,8,14]
///hide
#include <list>
#include <algorithm>
///unhide
#include <mutex>

std::list<int> some_list;
std::mutex some_mutex;

void add_to_list(int new_value)
{
    std::lock_guard<std::mutex> guard(some_mutex);
    some_list.push_back(new_value);
}

bool list_contains(int value_to_find)
{
    std::lock_guard<std::mutex> guard(some_mutex);
    return std::find(some_list.begin(), some_list.end(), value_to_find)
        != some_list.end();
}
```

---

## locking multiple mutexes

```cpp [8-14|18-20]
///compiler=clang600
///options=-pthread
///hide
#include <mutex>
#include <thread>
#include <vector>

///unhide
class X
{
private:
    std::vector<int> vec;
    std::mutex m;
public:
    X(const std::vector<int>& vec): vec{vec} {}
    friend void swap(X& lhs, X& rhs)
    {
        if(&lhs==&rhs) return;
        std::lock_guard<std::mutex> lock_a{lhs.m};
        std::lock_guard<std::mutex> lock_b{rhs.m};
        std::swap(lhs.vec, rhs.vec);
    }
};

///hide
int main() {
std::vector<int> i1, i2; 
///unhide
X x1{i1}, x2{i2};
std::thread t1{[&]{ swap(x1, x2); }};
std::thread t2{[&]{ swap(x2, x1); }};
///hide
t1.join();
t2.join();
}
```

---

## use `std::lock`

```cpp [11-13]
///compiler=clang600
///options=-pthread
///hide
#include <mutex>
#include <thread>
#include <vector>

///unhide
class X
{
private:
    std::vector<int> vec;
    std::mutex m;
public:
    X(const std::vector<int>& vec): vec{vec} {}
    friend void swap(X& lhs, X& rhs)
    {
        if(&lhs==&rhs) return;
        std::lock(lhs.m, rhs.m);
        std::lock_guard<std::mutex> lock_a{lhs.m, std::adopt_lock};
        std::lock_guard<std::mutex> lock_b{rhs.m, std::adopt_lock};
        std::swap(lhs.vec, rhs.vec);
    }
};

///hide
int main() {
std::vector<int> i1, i2; 
///unhide
X x1{i1}, x2{i2};
std::thread t1{[&]{ swap(x1, x2); }};
std::thread t2{[&]{ swap(x2, x1); }};
///hide
t1.join();
t2.join();
}
```

---

## use `std::scoped_lock` (C++17)

```cpp [11]
///compiler=clang600
///options=-std=c++17 -pthread
///hide
#include <mutex>
#include <thread>
#include <vector>

///unhide
class X
{
private:
    std::vector<int> vec;
    std::mutex m;
public:
    X(const std::vector<int>& vec): vec{vec} {}
    friend void swap(X& lhs, X& rhs)
    {
        if(&lhs==&rhs) return;
        std::scoped_lock<std::mutex,std::mutex> guard{lhs.m, rhs.m};
        std::swap(lhs.vec, rhs.vec);
    }
};

///hide
int main() {
std::vector<int> i1, i2; 
///unhide
X x1{i1}, x2{i2};
std::thread t1{[&]{ swap(x1, x2); }};
std::thread t2{[&]{ swap(x2, x1); }};
///hide
t1.join();
t2.join();
}
```

---

## or use `std::unique_lock`

```cpp [11-13]
///compiler=clang600
///options=-pthread
///hide
#include <mutex>
#include <thread>
#include <vector>

///unhide
class X
{
private:
    std::vector<int> vec;
    std::mutex m;
public:
    X(const std::vector<int>& vec): vec{vec} {}
    friend void swap(X& lhs, X& rhs)
    {
        if(&lhs==&rhs) return;
        std::unique_lock<std::mutex> lock_a{lhs.m,std::defer_lock};
        std::unique_lock<std::mutex> lock_b{rhs.m,std::defer_lock};
        std::lock(lock_a,lock_b);
        std::swap(lhs.vec, rhs.vec);
    }
};

///hide
int main() {
std::vector<int> i1, i2; 
///unhide
X x1{i1}, x2{i2};
std::thread t1{[&]{ swap(x1, x2); }};
std::thread t2{[&]{ swap(x2, x1); }};
///hide
t1.join();
t2.join();
}
```

Note: `unique_lock` has more features than `lock_guard` but is also more expensive.

---

## transferring mutex ownership

```cpp [1-2,20,21|4-17|24-31]
///compiler=clang600
///options=-pthread
///hide
#include <mutex>
#include <vector>
#include <thread>

///unhide
template<typename T>
class Synchronized {
public:
    struct Locked {
      std::unique_lock<std::mutex> m_lock;
      T* m_data;

Locked(std::mutex& mutex, T& data)
        : m_lock{mutex}
        , m_data{&data}
      {}

T* operator->() { return m_data; }
    };
    Locked operator->() {
        return {m_mutex, m_data};
    }

private:
    std::mutex m_mutex;
    T m_data;
};
int main() {
    Synchronized<std::vector<int>> pv;
    auto foo = [&pv]{
        pv->push_back(42);
    };
    std::thread t1{foo}, t2{foo};
    t1.join();
    t2.join();
    return pv->size();
}

```

Note: proposed for standardization in [n4033](https://wg21.link/n4033)

---

## single threaded lazy initialization

```cpp []
///hide
#include <memory>

struct Resource {
  void doSomething();
};

///unhide
std::unique_ptr<Resource> pResource;

void foo() {
  if(!pResource) {
    pResource.reset(new Resource);
  }
  pResource->doSomething();
}
```

---

## multi-threaded lazy initialization

```cpp []
///hide
#include <memory>
#include <mutex>

struct Resource {
  void doSomething();
};

///unhide
std::unique_ptr<Resource> pResource;
std::mutex resourceMutex;

void foo() {
  {
    std::lock_guard<std::mutex> lk(resourceMutex);
    if(!pResource) {
      pResource.reset(new Resource);
    }
  }
  pResource->doSomething();
}
```

Note: causes serialization of threads using the resource

---

## double-checked locking pattern

```cpp []
///hide
#include <memory>
#include <mutex>

struct Resource {
  void doSomething();
};

///unhide
std::unique_ptr<Resource> pResource;
std::mutex resourceMutex;

void foo() {
  if(!pResource) {
    std::lock_guard<std::mutex> lk(resourceMutex);
    if(!pResource) {
      pResource.reset(new Resource);
    }
  }
  pResource->doSomething();
}
```

Note: there's a possibility for a race condition if the compiler reorders the code on line 11 to first set the pointer to be non-empty before completely constructing the resource.

---

## use `std::call_once`

```cpp [2,5-7]
///hide
#include <memory>
#include <mutex>

struct Resource {
  void doSomething();
};

///unhide
std::unique_ptr<Resource> pResource;
std::once_flag resourceFlag;

void foo() {
  std::call_once(resourceFlag, []{
    pResource.reset(new Resource);
  });
  pResource->doSomething();
}
```

Note: `std::call_once` will typically have a lower overhead than using a mutex explicitly, especially when the initialization has already been done

---

## safe static init

```cpp []
///hide
struct Resource {
  void doSomething();
};

///unhide
void foo()
{
  static Resource resource;
  resource.doSomething();
}
```

---

## read write mutex (C++17)

```cpp [1,5-6,11-13,18]
///options=-std=c++17
///hide
#include <map>
#include <string>
#include <mutex>
///unhide
#include <shared_mutex>

///hide
class DnsEntry {};

///unhide
class DnsCach {
public:
  const DnsEntry* findEntry(const std::string& domain) const {
    std::shared_lock<std::shared_mutex> lk(m_entryMutex);
    const auto it = m_entries.find(domain);
    return (it == m_entries.end()) ? nullptr : &it->second;
  }

void update_or_add_entry(const std::string& domain,
                           const DnsEntry& dns_details) {
    std::unique_lock<std::shared_mutex> lk(m_entryMutex);
    m_entries[domain] = dns_details;
  }
private:
  std::map<std::string, DnsEntry> m_entries;
  mutable std::shared_mutex m_entryMutex;
};
```

---

## can't lock mutex multiple times

```cpp
///hide
#include <mutex>

///unhide
struct C {
  void func1() {
    std::lock_guard<std::mutex> lock{m_mutex};
    // do work
  }

void func2() {
    std::lock_guard<std::mutex> lock{m_mutex};
    // do work
    func1();
    // do more work
  }

std::mutex m_mutex;
};
```

---

## use `std::recursive_mutex`

```cpp
///hide
#include <mutex>

///unhide
struct C {
  void func1() {
    std::lock_guard<std::recursive_mutex> lock{m_mutex};
    // do work
  }

void func2() {
    std::lock_guard<std::recursive_mutex> lock{m_mutex};
    // do work
    func1();
    // do more work
  }

std::recursive_mutex m_mutex;
};
///hide

int main() {
  C{}.func2();
}
```

---

## or [better](https://quick-bench.com/q/yK3BksMuPRaQqs3sOMtyCtW5lW8)

```cpp
///hide
#include <mutex>

///unhide
struct C {
  void func1() {
    std::lock_guard<std::mutex> lock{m_mutex};
    func1_impl();
  }

void func2() {
    std::lock_guard<std::mutex> lock{m_mutex};
    func1_impl();
  }

void func1_impl() {}

std::mutex m_mutex;
};
///hide

int main() {
  C{}.func2();
}
```

---

## synchronization

Note: besides from protecting shared data, many times one thread needs to wait for data prepared by a different thread or get the result of some computation done by a thread.

---

## waiting for an event

```cpp []
///compiler=clang600
///options=-pthread
///hide
#include <mutex>
#include <thread>
#include <iostream>

///unhide
bool flag;
std::mutex m;

void waitForFlag() {
  const auto check_flag = []{
    std::lock_guard<std::mutex> lk(m);
    return flag;
  };
  while(!check_flag());
  std::cout << "flag set\n";
}
///hide

int main() {
    std::thread t1{waitForFlag};
    std::thread t2{[]{
        std::this_thread::sleep_for(std::chrono::seconds{1});
        std::lock_guard<std::mutex> lk(m);
        flag = true;
    }};

t2.join();
    t1.join();
}
```

Note: waist of cpu cycles and locking prevents other thread from setting flag

---

## waiting for an event

```cpp []
///compiler=clang600
///options=-pthread
///hide
#include <mutex>
#include <thread>
#include <iostream>

///unhide
bool flag;
std::mutex m;

void waitForFlag() {
  const auto check_flag = []{
    std::lock_guard<std::mutex> lk(m);
    return flag;
  };
  while(!check_flag()) {
    using namespace std::chrono_literals;
    std::this_thread::sleep_for(100ms);
  }
  std::cout << "flag set\n";
}
///hide

t2.join();
    t1.join();
}
```

Note: hard to get the sleep period right

---

## condition variables

```cpp [1,4|7-8|13]
///compiler=clang600
///options=-pthread
///hide
#include <mutex>
#include <thread>
#include <iostream>
///unhide
#include <condition_variable>

std::mutex m;
std::condition_variable dataCond;

void waitForFlag() {
  std::unique_lock<std::mutex> lk(m);
  dataCond.wait(lk);
  std::cout << "flag set\n";
}

void setFlag() {
  dataCond.notify_one();
}
///hide

int main() {
    std::thread t1{waitForFlag};
    std::thread t2{setFlag};

t2.join();
    t1.join();
}
```

Note: need to use `unique_lock`. Note that the condition variable is notified with the mutex unlocked so that, if the waiting thread wakes immediately, it doesn’t then have to block again, waiting for the notifier to unlock the mutex. 
But where is the condition?

---

## producer consumer

```cpp [2,5-14|17-32|21-23]
///hide
#include <mutex>
#include <condition_variable>
#include <queue>

struct DataChunk {};

bool moreDataToPrepare();
DataChunk prepareData();
bool isLastChunk(const DataChunk&);
void process(const DataChunk&);

///unhide
std::mutex mut;
std::queue<DataChunk> dataQueue;
std::condition_variable dataCond;

void dataPreparationThread() {
  while(moreDataToPrepare()) {
    const auto data = prepareData();
    {
      std::lock_guard<std::mutex> lk(mut);
      dataQueue.push(data);
    }
    dataCond.notify_one();
  }
}

void dataProcessingThread() {
  while(true) {
    const auto data = []{
      std::unique_lock<std::mutex> lk(mut);
      dataCond.wait(lk, []{
        return !dataQueue.empty();
      });
      const auto data = dataQueue.front();
      dataQueue.pop();
      return data;
    }();
    process(data);
    if(isLastChunk(data))
      break;
  }
}
```

Note: the condition var. calls checks the condition before going to sleep.
the condition variable unlocks the mutex when waiting and re-locks when it's awaken to check the condition.
There's also `notify_all` for awakening **all** threads waiting on the same condition.

---

## platform specific

```cpp [11-19]
///options=-pthread
///hide
#include <pthread.h>
#include <iostream>
#include <thread>
#include <cstring>

///unhide
void f(int num) {
  std::this_thread::sleep_for(std::chrono::seconds(1));

sched_param sch;
  int policy;
  pthread_getschedparam(pthread_self(), &policy, &sch);
  std::cout << "Thread " << num << " is executing at priority "
            << sch.sched_priority << '\n';
}

///hide
int main() {
///unhide
std::thread t1(f, 1), t2(f, 2);

sched_param sch;
int policy;
pthread_getschedparam(t1.native_handle(), &policy, &sch);
sch.sched_priority = 20;
if (pthread_setschedparam(t1.native_handle(), SCHED_FIFO, &sch)) {
  std::cout << "Failed to setschedparam: " << std::strerror(errno) << '\n';
}
///hide

t1.join(); 
t2.join();
}
```

Note:: there's a similar facility for mutex types

---

## std::future

Note: `std::thread` doesn't return a value. Although we could send it a reference to the result and then wait there is a better alternative.

---

## `std::future`

Getting the result of an asynchronous operation

```cpp
template< class T > class future {
public:
  // returns the result
  T get();

// is this attached to an operation result
  bool valid() const noexcept;
};
```

Note: How to obtain a future?

---

## `std::async`

runs a function asynchronously

```cpp
///hide
#include <iostream>
///unhide
#include <future>

///hide
int findTheAnswerToLifeTheUniverseAndEverything();
void doOtherStuff();

void foo() {
///unhide
std::future<int> theAnswer 
  = std::async(findTheAnswerToLifeTheUniverseAndEverything);
doOtherStuff();
std::cout 
  << "The answer is " 
  << theAnswer.get() // blocks
  << '\n';
///hide
}
```

---

## launch policy

```cpp
///hide
#include <string>
#include <future>

///unhide
struct X
{
  void foo(int,std::string const&);
  std::string bar(std::string const&);
};

std::string run() {
  X x;
  // on a separate thread, calls p->foo(42,“hello”) where p is &x
  auto f1 = std::async(std::launch::async, &X::foo, &x, 42 , "hello");

// during f2.get(), calls x.bar("goodbye")
  auto f2 = std::async(std::launch::deferred, &X::bar , std::ref(x), "goodbye");
  return f2.get();

} // ~f1 will block
```

Note: without a policy, it's implementation defined

---

## be careful

```cpp
///hide
#include <future>
#include <functional>

///unhide
void runInParallel(std::function<void()> f1, 
                   std::function<void()> f2)
{
  std::async(f1); // start as though in a new thread?
  f2();           // execute in main thread
}
```

Note: it's sequential because the future returned by `async` is blocked on destruction

---

## `std::packaged_task`

An asynchronous `std::function`

```cpp [1-2,18-26|1-2,4-15]
///hide
#include <deque>
#include <mutex>
#include <future>
#include <thread>
#include <utility>

bool shutdownReceived();

///unhide
std::mutex m;
std::deque<std::packaged_task<void()>> tasks;

void guiThread() {
  while(!shutdownReceived()) {
    auto task = []{
      std::lock_guard<std::mutex> lk(m);
      if(tasks.empty())
        return std::packaged_task<void()>{};
      auto task = std::move(tasks.front());
      tasks.pop_front();
      return task;
    }();
    if (task.valid())
      task();
  }
}

template<typename Func>
std::future<void> sendTaskToGui(Func f)
{
  std::packaged_task<void()> task(std::move(f));
  std::future<void> res = task.get_future();
  std::lock_guard<std::mutex> lk(m);
  tasks.push_back(std::move(task));
  return res;
}

```

---

## `std::promise`

implementing a packaged task

```cpp [5-6,13,16]
///hide
#include <functional>
#include <future>

///unhide
template <typename> class my_task;

template <typename R, typename ...Args>
class my_task<R(Args...)> {
  std::function<R(Args...)> fn;
  std::promise<R> pr;
public:
  template <typename ...Ts>
  explicit my_task(Ts &&... ts) : fn(std::forward<Ts>(ts)...) { }

template <typename ...Ts>
  void operator()(Ts &&... ts) {
    pr.set_value(fn(std::forward<Ts>(ts)...));
  }

std::future<R> get_future() { return pr.get_future(); }
};
```

---

## async accumulate

```cpp [1-2|4-13|15-19|21-31|33-36]
///hide
#include <future>
#include <numeric>
#include <vector>

///unhide
template <typename Iterator, typename T, ptrdiff_t MIN_PER_THREAD = 25>
T async_accumulate(Iterator first, Iterator last, T init)
{
  const auto length = std::distance(first, last);
  if (!length)
    return init;

const auto max_threads = (length + MIN_PER_THREAD - 1) / MIN_PER_THREAD;
  const auto hardware_threads = std::thread::hardware_concurrency();
  const auto num_threads =
      std::min<ptrdiff_t>(hardware_threads != 0 ? hardware_threads : 2,
                          max_threads);
  const auto block_size = length / num_threads;

std::vector<std::future<T>> results;
  results.reserve(num_threads);
  const auto accumulator = [](Iterator first, Iterator last) {
    return std::accumulate(first, last, 0);
  };

auto block_start = first;
  for (auto block_end = std::next(block_start, block_size); 
       std::distance(block_start, last) >= block_size; 
       block_start = block_end, block_end = std::next(block_start, block_size))
  {
    results.push_back(std::async(accumulator, block_start, block_end));
  };

std::promise<T> pr;
  results.push_back(pr.get_future());
  pr.set_value(accumulator(block_start, last));

return std::accumulate(results.begin(), results.end(), init, 
                         [](int current, std::future<T> &rhs) {
    return current + rhs.get();
  });
}
```

---

## sharing the future

```cpp [1-2|4-11|13-14|18-25|27-36]
///compiler=clang600
///options=-pthread
///hide
#include <iostream>
#include <future>
#include <chrono>

int main()
{
///unhide
std::promise<void> ready_promise, t1_ready_promise, t2_ready_promise;
std::shared_future<void> ready_future(ready_promise.get_future());

auto fun =
    [](std::shared_future<void> ready_future,
       std::promise<void> ready_promise,
       std::chrono::time_point<std::chrono::high_resolution_clock>& start) {
      ready_promise.set_value();
      ready_future.wait();  // waits for the signal from main()
      return std::chrono::high_resolution_clock::now() - start;
    };

auto fut1 = t1_ready_promise.get_future();
auto fut2 = t2_ready_promise.get_future();

std::chrono::time_point<std::chrono::high_resolution_clock> start;

auto result1 = std::async(std::launch::async, fun, ready_future,
                          std::move(t1_ready_promise), std::ref(start));
auto result2 = std::async(std::launch::async, fun, ready_future,
                          std::move(t2_ready_promise), std::ref(start));

// wait for the threads to become ready
fut1.wait();
fut2.wait();

// the threads are ready, start the clock
start = std::chrono::high_resolution_clock::now();

// signal the threads to go
ready_promise.set_value();

std::cout << "Thread 1 received the signal "
          << result1.get().count() << " ms after start\n"
          << "Thread 2 received the signal "
          << result2.get().count() << " ms after start\n";
///hide
}
```

Note: `std::future::get` can only be called by a single thread. For multiple threads referring the same data, use `std::shared_ptr`.
Access to the same shared state from multiple threads is safe if each thread does it through its own copy of a shared_future object.

---

## alternatively

```cpp
///hide
#include <future>

///unhide
std::promise<void> ready_promise;
auto ready_future = ready_promise.get_future().share();
```

---

## duration based waits

```cpp [3-5]
///hide
#include <future>
#include <chrono>

int some_task();
void do_something_with(int);

void foo() {
///unhide
using namespace std::chrono_literals;

auto f = std::async(some_task);
if(f.wait_for(35ms) == std::future_status::ready)
  do_something_with(f.get());
///hide
}
```

---

## time point based waits

```cpp [8-15]
///hide
#include <condition_variable>
#include <mutex>
#include <chrono>

///unhide
std::condition_variable cv;
bool done;
std::mutex m;

bool wait_loop()
{
  using namespace std::chrono_literals;
  const auto timeout = std::chrono::steady_clock::now() + 500ms;
  std::unique_lock<std::mutex> lk(m);
  while(!done)
  {
    if(cv.wait_until(lk, timeout) == std::cv_status::timeout)
      break;
  }
  return done;
}
```

---

## timed lock

```cpp [4,10]
///compiler=clang600
///options=-pthread
///hide
#include <mutex>
#include <future>
#include <cassert>

///unhide
using namespace std::chrono_literals;
using clk = std::chrono::steady_clock;

std::timed_mutex m;

int main() {
  m.lock();
  auto f = std::async(std::launch::async, []{
    const auto t0 = clk::now();
    assert(m.try_lock_for(300ms) == true);
    const auto t1 = clk::now();
    m.unlock();
    auto d = t1 - t0 - 250ms;
    assert(d < 50ms);
  });
  std::this_thread::sleep_for(250ms);
  m.unlock();
  f.wait();
}
```

---

## Error handling

Note: It's hard to imaging but there are something errors in a program. How do we deal with them in a multithreaded code?

---

## `std::system_error`

thrown by several threading functions

```cpp
///compiler=clang600
///options=-pthread
///hide
#include <thread>
#include <iostream>

int main() {
///unhide
try {
  std::thread{}.join();
} catch (const std::system_error& ex) {
  std::cerr 
    << ex.code() 
    << ", " 
    << ex.code().message() 
    << '\n';
}
///hide
}
```

---

## `std::future_error`

thrown by futures

```cpp
///compiler=clang600
///options=-pthread
///hide
#include <future>
#include <iostream>
#include <thread>

int main() {
///unhide
try {
  auto f = std::promise<int>{}.get_future();
  f.get();
} catch (const std::future_error& ex) {
  std::cerr 
    << ex.code() 
    << ", " 
    << ex.code().message() 
    << '\n';
}
///hide
}
```

---

## catch exception

```cpp []
///hide
#include <cmath>
#include <iostream>
#include <stdexcept>

///unhide
double throwingSqrt(double x)
{
    if (x < 0)
    {
      throw std::out_of_range("x<0");
    }
    return sqrt(x);
}

///hide
int main() {
///unhide
try {
  auto y = throwingSqrt(-1);
} catch (const std::exception& ex) {
  std::cerr << ex.what() << '\n';
}
///hide
}
```

---

## in a thread

```cpp []
///compiler=clang600
///options=-pthread
///hide
#include <cmath>
#include <iostream>
#include <stdexcept>
#include <thread>

double throwingSqrt(double x) {
  if (x < 0) {
    throw std::out_of_range("x<0");
  }
  return sqrt(x);
}

int main() {
///unhide
try {
  double result;
  std::thread t{[&result](double x) {
                  result = throwingSqrt(x);
                }, -1};
  t.join();
} catch (const std::exception& ex) {
  std::cerr << ex.what() << '\n';
}
///hide
}
```

---

## transfer the exception

```cpp [3,5-9,13-15]
///compiler=clang600
///options=-pthread
///hide
#include <cmath>
#include <iostream>
#include <stdexcept>
#include <thread>

double throwingSqrt(double x) {
  if (x < 0) {
    throw std::out_of_range("x<0");
  }
  return sqrt(x);
}

int main() {
///unhide
try {
  double result;
  std::exception_ptr ptr;
  std::thread t{[&result, &ptr](double x) {
                  try {
                    result = throwingSqrt(x);
                  } catch (...) {
                    ptr = std::current_exception();
                  }
                }, -1};
  t.join();
  if (ptr) {
    std::rethrow_exception(ptr);
  }
} catch (const std::exception& ex) {
  std::cerr << ex.what() << '\n';
}
///hide
}
```

---

## use `promise`

```cpp [2-3,5-9,12]
///compiler=clang600
///options=-pthread
///hide
#include <cmath>
#include <iostream>
#include <stdexcept>
#include <thread>
#include <future>

double throwingSqrt(double x) {
  if (x < 0) {
    throw std::out_of_range("x<0");
  }
  return sqrt(x);
}

int main() {
///unhide
try {
  std::promise<double> p;
  auto f = p.get_future();
  std::thread t{[&p](double x) {
                  try {
                    p.set_value(throwingSqrt(x));
                  } catch (...) {
                    p.set_exception(std::current_exception());
                  }
                }, -1};
  t.join();
  double y = f.get();
} catch (const std::exception& ex) {
  std::cerr << ex.what() << '\n';
}
///hide
}
```

---

## use `async`

```cpp [2]
///compiler=clang600
///options=-pthread
///hide
#include <cmath>
#include <iostream>
#include <stdexcept>
#include <future>

double throwingSqrt(double x) {
  if (x < 0) {
    throw std::out_of_range("x<0");
  }
  return sqrt(x);
}

int main() {
///unhide
try {
  double y = std::async(throwingSqrt, -1).get();
} catch (const std::exception& ex) {
  std::cerr << ex.what() << '\n';
}
///hide
}
```

---

## `std::atomic` and memory ordering

Source: Fedor Pikus, [C++ atomics, from basic to advanced. What do they really do?](https://www.youtube.com/watch?v=ZQFzMfHIxng)

</div>

Note: all the synchronization and data sharing protection tools we've covered couldn't work without a well defined memory model. 
C++11 contains a well defined memory model along with low level synchronization constructs called 'atomics'.

---

## atomic operation

indivisible - can’t be observed half-done from any thread in the system.

---

## atomic type

all **single** operations on are atomic

---

## `std::atomic`

```cpp
template< class T >
struct atomic;
```

`T` must be *trivially copyable*

Note: can be `memcpy`-ed.

---

## allowed operations

```cpp []
///hide
#include <cassert>
///unhide
#include <atomic>

struct Pair{int first; int second;};
std::atomic<Pair> x;

int main() {
  x.store(Pair{42, 43});
  assert(x.exchange(Pair{45, 45}).first == 42);
  assert(x.load().second == 45);
}
```

---

## pointer types

adds addition & subtraction

```cpp []
///hide
#include <cassert>
///unhide
#include <atomic>

int arr[42] = {0};
std::atomic<int*> x{arr};

int main() {
  assert(x.fetch_add(2) == arr);
  assert(x.fetch_sub(1) == &arr[2]);
  assert(x.load() == &arr[1]);
}
```

---

## pointer types

alternatively

```cpp []
///hide
#include <cassert>
///unhide
#include <atomic>

int arr[42] = {0};
std::atomic<int*> x{arr};

int main() {
  assert((x += 2) == &arr[2]);
  assert(--x == &arr[1]);
}
```

---

## integral types

adds bitwise operations

```cpp []
///hide
#include <cassert>
///unhide
#include <atomic>

std::atomic<uint32_t> x{0xFFF};

int main() {
  assert(x.fetch_and(0xF0F) == 0xFFF);
  assert(x.fetch_or(0x070) == 0xF0F);
  assert(x.fetch_xor(0xFFF) == 0xF7F);
  assert(x.load() == 0x080);
}
```

---

## integral types

adds bitwise operations

```cpp []
///hide
#include <cassert>
///unhide
#include <atomic>

std::atomic<uint32_t> x{0xFFF};

int main() {
  assert((x &= 0xF0F) == 0xF0F);
  assert((x |= 0x070) == 0xF7F);
  assert((x ^= 0xFFF) == 0x080);
}
```

---

## only single operations

```cpp
///hide
#include <atomic>

///unhide
std::atomic<int> x;

///hide
int main() {
///unhide
x = x + 2; // not atomic
///hide
}
```

---

## might be emulated

```cpp
///options=-latomic
///hide
#include <atomic>
#include <cassert>

int main() {
///unhide
assert(std::atomic<int>{}.is_lock_free());

struct S{int arr[4];};
assert(not std::atomic<S>{}.is_lock_free());
///hide
}
```

---

## compile time check (C++17)

```cpp
///options=-std=c++17
///hide
#include <atomic>

///unhide
static_assert(std::atomic<bool>::is_always_lock_free);
```

---

## Compare-and-swap (CAS)

used in most lock-free algorithms

```cpp
///hide
#include <atomic>

///unhide
std::atomic<int> x{0};

void atomic_multiply(int y) {
  int x0 = x;
  while ( !x.compare_exchange_strong(x0, x0 * y) );
}
```

---

## Pseudo code

```cpp [2-3|4|5-6|7-8]
///hide
struct Lock{};

template<typename T>
struct atomic {
T value;
///unhide
bool compare_exchange_strong(T& old_v, T new_v) {
  T tmp = value; // Current value of the atomic
  if (tmp != old_v) { old_v = tmp; return false; }
  Lock l; // Get exclusive access
  tmp = value; // value could have changed!
  if (tmp != old_v) { old_v = tmp; return false; }
  value = new_v;
  return true;
}
///hide
};
```

Note: double-checked locking pattern. Lock is not a real mutex but some form of exclusive access implemented in hardware

---

## Pseudo code - weak

```cpp [1,4-5]
///hide
struct TimedLock{
  bool locked();
};

template<typename T>
struct atomic {
T value;
///unhide
bool compare_exchange_weak(T& old_v, T new_v) {
  T tmp = value; // Current value of the atomic
  if (tmp != old_v) { old_v = tmp; return false; }
  TimedLock tl; // Get exclusive access
  if (!tl.locked()) return false; // old_v is correct
  tmp = value; // value could have changed!
  if (tmp != old_v) { old_v = tmp; return false; }
  value = new_v;
  return true;
}
///hide
};
```

---

## reading and writing

```cpp []
///hide
#include <vector>
#include <atomic>
#include <iostream>
#include <thread>

///unhide
std::vector<int> data;
std::atomic<bool> ready(false);

void writer() {
  data.push_back(42);
  ready.store(true);
}

void reader() {
  while (not ready.load()) {
      std::this_thread::sleep_for(std::chrono::milliseconds(1));
  }
  std::cout << "The answer is " << data.back() << '\n';
}
```

Note: 
- Atomics are used to get exclusive access to memory or to
reveal memory to other threads
- What guarantees that other threads see this memory in
the desired state

---

## memory barriers

- How changes to memory made by one thread become visible to other threads
- modeled by `std::memory_order` enum

---

### `std::memory_order_relaxed`

- no synchronization or ordering constraints imposed on **other** reads or writes.
- operations before atomic operation can be observed after it and vice versa

---

## counter

```cpp
///hide
#include <atomic>
#include <cstddef>

///unhide
class S{
  static std::atomic<size_t> instanceCount;

S() {
    instanceCount.fetch_add(1, std::memory_order_relaxed);
  }

~S() {
    instanceCount.fetch_sub(1, std::memory_order_relaxed);
  }
};
```

---

### `std::memory_order_acquire`

- all memory operations scheduled after the barrier in the program order become visible after the barrier
- reads and writes, in the thread doing the atomic operation, cannot be reordered from after to before the barrier

---

### `std::memory_order_release`

- all memory operations scheduled before the barrier in the program order become visible before the barrier
- reads and writes, in the thread doing the atomic operation cannot be reordered from before to after the barrier

---

## `std::atomic_flag`

```cpp
///hide
#include <atomic>

///unhide
class spinlock_mutex {
    std::atomic_flag flag;
public:
    spinlock_mutex(): flag{ATOMIC_FLAG_INIT}
    {}

void lock() {
      while(flag.test_and_set(std::memory_order_acquire));
    }

void unlock() {
      flag.clear(std::memory_order_release);
    }
};
```

---

## Release-Acquire ordering

```cpp []
///hide
#include <vector>
#include <atomic>
#include <iostream>
#include <thread>

///unhide
std::vector<int> data;
std::atomic<bool> ready(false);

void writer() {
  data.push_back(42);
  ready.store(true, std::memory_order_release);
}

void reader() {
  while (not ready.load(std::memory_order_acquire)) {
      std::this_thread::sleep_for(std::chrono::milliseconds(1));
  }
  std::cout << "The answer is " << data.back() << '\n';
}
```

---

### `std::memory_order_acq_rel`

- no operation can move across the barrier
- but only if both threads use the same atomic variable

---

## read modify write

```cpp []
///hide
#include <vector>
#include <atomic>
#include <cassert>

///unhide
std::vector<int> data;
std::atomic<int> flag{0};

void writer() {
  data.push_back(42);
  flag.store(1, std::memory_order_release);
}

void middleMan() {
  int expected = 1;
  while (!flag.compare_exchange_strong(expected, 2, 
                                       std::memory_order_acq_rel));
}

void reader() {
  while (flag.load(std::memory_order_acquire) < 2) ;
  assert(data.back() == 42);
}
```

---

## read modify write

```cpp []
///hide
#include <vector>
#include <atomic>
#include <cassert>

///unhide
std::vector<int> data;
std::atomic<int> flag{0};

void writer() {
  data.push_back(42);
  flag.store(1, std::memory_order_release);
}

void middleMan() {
  int expected = 1;
  while (!flag.compare_exchange_strong(expected, 2, 
                                       std::memory_order_acq_rel,
                                       std::memory_order_relaxed));
}

void reader() {
  while (flag.load(std::memory_order_acquire) < 2) ;
  assert(data.back() == 42);
}
```

---

### `std::memory_order_seq_cst`

- sequential consistency
- single total modification order of all atomics
- the default order
- makes your programs slow

---

## a simple thread pool

```cpp [2-4|6-15|18-27|29|31-39]
///hide
#include <algorithm>
#include <functional>
#include <future>
#include <vector>

template <typename T>
struct thread_safe_queue {
  template <typename U = T>
  void push(U&&);
  bool try_pop(T&);
};

class thread_joiner {
 public:
  explicit thread_joiner(std::thread thread) : m_thread{std::move(thread)} {}
  ~thread_joiner() {
    if (m_thread.joinable()) {
      m_thread.join();
    }
  }
  thread_joiner(const thread_joiner&) = delete;
  thread_joiner(thread_joiner&&) = default;
  thread_joiner& operator=(const thread_joiner&) = delete;
  thread_joiner& operator=(thread_joiner&&) = default;

private:
  std::thread m_thread;
};

///unhide
class thread_pool {
  thread_safe_queue<std::function<void()>> work_queue;
  std::atomic<bool> done{false};
  std::vector<thread_joiner> threads;

void worker_thread() {
    while (!done) {
      std::function<void()> task;
      if (work_queue.try_pop(task)) {
        task();
      } else {
        std::this_thread::yield();
      }
    }
  }

public:
  thread_pool() {
    const auto thread_count = std::thread::hardware_concurrency();
    threads.reserve(thread_count);
    std::generate_n(std::back_inserter(threads), 
                    thread_count, 
                    [this] {
      return thread_joiner{std::thread{&thread_pool::worker_thread, 
                                       this}};
    });
  }

~thread_pool() { done = true; }

template <typename FunctionType>
  std::future<typename std::result_of<FunctionType()>::type> submit(
      FunctionType f) {
    using result_type = typename std::result_of<FunctionType()>::type;
    std::packaged_task<result_type()> task(std::move(f));
    const auto res = task.get_future();
    work_queue.push([task] { task(); });
    return res;
  }
};
```

Note: there's a lot of contention on the queue. to avoid that we'll add a separate work queue for each thread

---

## `thread_local`

```cpp [2-5|9-25|47-52]
///hide
#include <algorithm>
#include <functional>
#include <future>
#include <vector>
#include <queue>

template <typename T>
struct thread_safe_queue {
  template <typename U = T>
  void push(U&&);
  bool try_pop(T&);
};

class thread_joiner {
 public:
  explicit thread_joiner(std::thread thread) : m_thread{std::move(thread)} {}
  ~thread_joiner() {
    if (m_thread.joinable()) {
      m_thread.join();
    }
  }
  thread_joiner(const thread_joiner&) = delete;
  thread_joiner(thread_joiner&&) = default;
  thread_joiner& operator=(const thread_joiner&) = delete;
  thread_joiner& operator=(thread_joiner&&) = default;

private:
  std::thread m_thread;
};

///unhide
class thread_pool {
  thread_safe_queue<std::function<void()>> pool_work_queue;
  using local_queue = std::queue<std::function<void()>>;
  static thread_local std::unique_ptr<local_queue> 
    local_work_queue;
  std::atomic<bool> done{false};
  std::vector<thread_joiner> threads;

void worker_thread() {
    local_work_queue = std::make_unique<local_queue>();

while (!done) {
      std::function<void()> task;
      if (not local_work_queue->empty()) {
        task = std::move(local_work_queue->front());
        local_work_queue->pop();
        task();
      }
      else if (pool_work_queue.try_pop(task))  {
        task();
      } else {
        std::this_thread::yield();
      }
    }
  }

~thread_pool() { done = true; }

template <typename FunctionType>
  std::future<typename std::result_of<FunctionType()>::type> submit(
      FunctionType f) {
    using result_type = typename std::result_of<FunctionType()>::type;
    std::packaged_task<result_type()> task(std::move(f));
    const auto res = task.get_future();
    const auto work = [task] { task(); };
    if (local_work_queue) {
      local_work_queue->push(work);
    } else {
      pool_work_queue.push(work);
    }
    return res;
  }
};
```

---

----

---

## Regular Expressions library

Source: [The C++ Standard Library - A Tutorial and Reference, Nicolai Josuttis](http://www.cppstdlib.com/)

</div>

Note: Regular expressions were invented in the 1950s and made popular by the different UNIX test-processing utilities, like grep, lex, and sed. They are supported by many programming languages and from also arrived as part of C++11.

---

## matching xml tags

```cpp
///hide
#include <cassert>
///unhide
#include <regex>

///hide
int main() {
///unhide
std::regex reg{"<.*>.*</.*>"};
auto found1 = regex_match("<tag>value</tag>",
                          reg);
assert(found1);
auto found2 = regex_match("<tag>value<tag>",
                          reg);
assert(not found2);
auto found3 = regex_match("<tag>value</taq>",
                          reg);
assert(found3);
///hide
}
```

Note: we'll start with a classic example - XML parsing.

---

## same tag

```cpp
///hide
#include <cassert>
///unhide
#include <regex>

///hide
int main() {
///unhide
std::regex reg{"<(.*)>.*</\\1>"};
auto found1 = regex_match("<tag>value</tag>",
                          reg);
assert(found1);
auto found2 = regex_match("<tag>value</taq>",
                          reg);
assert(not found2);
///hide
}
```

Note: notice the double backslash that is caused by the fact that there are
two escaping steps here - one for the string and one for the regex.
It can be much worse though...

---

## backslash hell

```cpp
///hide
#include <regex>

///unhide
bool isStringLiteral(const std::string& input){
  std::regex reg{"('(?:[^\\\\']|\\\\.)*'|\"(?:[^\\\\\"]|\\\\.)*\")"};
  return std::regex_match(input, reg);
}
```

Note: this is a function for matching string literals of a language which allows both single and double quotes. Notice the group of 5 backslashes in a row.
To solve this C++11 added ...

---

## raw string literals

instead of

```cpp
const char concert_17_raw[] =
    "id: 17\n"
    "artist: \"Beyonce\"\n"
    "date: \"Wed Oct 10 12:39:54 EDT 2012\"\n"
    "price_usd: 200\n";
```

Note: this is a multiline string, enabled by automatic concatenation of adjacent string literals.
quotes need to be escaped and newlines to be explicitly written.

---

## raw string literals

write

```cpp
const char concert_17_raw[] = R"(
id: 17
artist: "Beyonce"
date: "Wed Oct 10 12:39:54 EDT 2012"
price_usd: 200
)";
```

Note: we define a raw string literal by wrapping it in `R"()"`. every whitespace inside matters so we need to align it all the way left to have each line starting without spaces. since quotes alone don't terminate the string they don't need to be quoted.
The type is still `const char[]`.

---

## custom delimiter

```cpp
///hide
#include <iostream>

int main() {
///unhide
std::cout << R"__(This contains quoted parens "()")__";
///hide
}
```

Note: if we need quoted parentheses inside the string we can have add a custom delimiter between the quotes and parentheses. 
custom delimiter is at most 16 characters except parentheses, backslash and spaces.

---

## hell cools down

```cpp
///hide
#include <regex>

///unhide
bool isStringLiteral(const std::string& input){
  std::regex reg{R"(('(?:[^\\']|\\.)*'|"(?:[^\\"]|\\.)*"))"};
  return std::regex_match(input, reg);
}
```

Note: using raw string literals make the above example much more readable.

---

## back to xml

```cpp [3]
///hide
#include <cassert>
///unhide
#include <regex>

///hide
int main() {
///unhide
std::regex reg{R"(<(.*)>.*</\1>)"};
auto found1 = regex_match("<tag>value</tag>",
                          reg);
assert(found1);
auto found2 = regex_match("<tag>value</tap>",
                          reg);
assert(not found2);
///hide
}
```

Note: similarly on the xml example.

---

## syntax

Note: There are several slightly different regular expression syntaxes: PCRE (Perl Compatible Regular Expressions), ECMAScript and several from POSIX. The syntax used, by default, by the C++ standard is a modified ECMAScript standard.
The reason is that it's standardized (unlike PCRE) and enables more features than POSIX.

---

## single character

|expression|meaning|
|----------|-------|
|`.`|any character except newline|
|`[...]`|one of `...`|
|`[^...]`|none of `...`|
|`\n`, `\t`, `\f`, `\r`, `\v`|newline, tab, form feed, carriage return, vertical tab|
|`\xhh`, `\uhhh`|hexadecimal or Unicode|
|`[[:charclass:]]`|one of the characters of class `charclass`|
|`\d`, `\s`, `\w`|character class shortcuts|
|`\D`, `\S`, `\W`|character class negators|

---

## character classes

|class|shortcut|meaning|
|-----|--------|-------|
|`alpha`| |letter|
|`lower`| |lowercase letter|
|`upper`| |uppercase letter|
|`digit`|`\d`|digit|
|`xdigit`| |hexadecimal digit|
|`alnum`| |letter or digit|
|`blank`| |space or tab|
|`space`|`\s`|space|
|`punct`| |punctuation|
|`graph`| |printable character|
|`cntrl`| |control character|
| |`\w`|letter, digit or underscore|

---

## quantifiers

|expression|minimum|maximum|
|----------|-------|-------|
|`*`|0|∞|
|`+`|1|∞|
|`?`|0|1|
|`{decimal}`|decimal|decimal|
|`{decimal,}`|decimal|∞|
|`{decimal0,decimal1}`|decimal0|decimal1|

---

## detect C++ identifiers

```cpp
///hide
#include <regex>

///unhide
bool isCppIdentifier(const std::string& input) {
  return std::regex_match(input, 
                          std::regex{"[_[:alpha:]]\\w*"});
}
```

---

## alternatives

|expression|meaning|
|----------|-------|
|`X\|Y`|either `X` or `Y`|

---

## grouping

|expression|meaning|
|----------|-------|
|`(...)`|a capture group|
|`(?...)`|a non-capturing group|
|`\1`, `\2`, ...|back reference to group|

---

## assertions

|expression|meaning|
|----------|-------|
|`^`|beginning of line|
|`$`|end of line|
|`\b`|word boundary|
|`\B`|not a word boundary|
|`(?=...)`|positive lookahead|
|`(?!...)`|negative lookahead|

---

## look ahead

match 4 letters at end of line
which consist of 1 or 2 letters
followed by 2 or 3 digits

```cpp
///hide
#include <regex>

///unhide
bool check(const std::string& input) {
  std::regex r{"(?=[a-z0-9]{4}$)[a-z]{1,2}[0-9]{2,3}"};
  return std::regex_search(input, r);
}
```

Note: if we didn't use lookahead the character would be
consumed by the left group and we wouldn't be able to match
them by rest of the regex.

---

## using another syntax

```cpp [3-4]
///hide
#include <cassert>
///unhide
#include <regex>

///hide
int main() {
///unhide
std::regex reg{R"(<$.*$>.*</\1>)", 
               std::regex_constants::grep};
auto found1 = regex_match("<tag>value</tag>",
                          reg);
assert(found1);
auto found2 = regex_match("<tag>value</tap>",
                          reg);
assert(not found2);
///hide
}
```

Note: the standard supports the POSIX grammars as well.
In the `grep` syntax parentheses have no special meaning by default
and need to be escaped to form a capture group.

---

## available syntaxes

|flag|syntax|
|----|------|
|`std::regex_constants::ECMAScript`|Modified ECMAScript|
|`std::regex_constants::basic`|basic POSIX|
|`std::regex_constants::extended`|extended POSIX|
|`std::regex_constants::awk`|grammar used by the awk utility|
|`std::regex_constants::grep`|basic POSIX + '\n' as an alternation separator|
|`std::regex_constants::egrep`|extended POSIX + '\n' as an alternation separator|

---

## basic vs. grep

```cpp
///hide
#include <cassert>
#include <regex>

int main() {
///unhide
std::string text = R"(multi
line
text)";
assert(std::regex_match(text, 
                        std::regex{"multi\nline\ntext", 
                                   std::regex_constants::basic}));
assert(not std::regex_match(text, 
                            std::regex{"multi\nline\ntext", 
                                       std::regex_constants::grep}));
assert(std::regex_match("text", 
                        std::regex{"multi\nline\ntext", 
                                   std::regex_constants::grep}));
///hide
}
```

Note: in the `grep` syntax, `\n` acts like an alternative.

---

## search input

```cpp
///hide
#include <regex>
#include <iostream>

int main() {
///unhide
std::string lines[] = {"Roses are #ff0000",
                       "violets are #0000ff",
                       "all of my bases belong to you"};

for (const auto &line : lines) {
  std::cout << line << ": " << std::boolalpha
            << std::regex_search(line, std::regex{"#[0-9a-f]{6}"}) 
            << '\n';
}
///hide
}
```

Note: until now we matched the whole input. We can check if part of the input matches
the regex with `regex_search`.
This example finds lines containing RGB colors.

---

## get match

```cpp
///hide
#include <regex>
#include <iostream>

int main() {
///unhide
std::string lines[] = {"Roses are #ff0000",
                       "violets are #0000ff",
                       "all of my bases belong to you"};

for (const auto &line : lines) {
  std::smatch m;
  if (std::regex_search(line, m, std::regex{"#[0-9a-f]{6}"})) {
    std::cout << "matched " << m.str() << '\n';
  }
}
///hide
}
```

Note: usually it's not enough to know if a regex matched but we need to know where and what was matched
exactly. To this end we can pass a match object to either `regex_match` or `regex_search`.

---

## `std::match_results`

templated on searched text iterator

|type|definition|
|----|----------|
|`std::cmatch`|`std::match_results<const char*>`|
|`std::wcmatch`|`std::match_results<const wchar_t*>`|
|`std::smatch`|`std::match_results<std::string::const_iterator>`|
|`std::wsmatch`|`std::match_results<std::wstring::const_iterator>`|

---

## other members

```cpp [1-4|6-9|11-14]
///hide
#include <regex>
#include <iostream>

int main() {
///unhide
std::cmatch m;
std::regex_search("XML tag: <tag-name>the value</tag-name>.",
                  m,
                  std::regex{"<(.*)>(.*)</(\\1)>"});

std::cout << "found " << m.length() << " length match\n"
          << "starting from position " << m.position() << '\n'
          << "after " << m.prefix().str() << '\n'
          << "and before " << m.suffix().str() << "\n";

std::cout << "submatches are:\n";
for (const auto& submatch : m) {
  std::cout << submatch << '\n';
}
///hide
}
```

---

## three ways to obtain `submatch` `n`

```cpp
///hide
#include <regex>

///unhide
template<typename BidirIt>
typename std::match_results<BidirIt>::string_type 
submatch(std::match_results<BidirIt> m, size_t n) {
  return m.str(n);
}
```

---

## three ways to obtain `submatch` `n`

```cpp
///hide
#include <regex>

///unhide
template<typename BidirIt>
typename std::match_results<BidirIt>::string_type 
submatch(std::match_results<BidirIt> m, size_t n) {
  return m[n].str();
}
```

---

## three ways to obtain `submatch` `n`

```cpp
///hide
#include <regex>

///unhide
template<typename BidirIt>
typename std::match_results<BidirIt>::string_type 
submatch(std::match_results<BidirIt> m, size_t n) {
  return *(m.begin() + n);
}
```

---

## other regex flags

|flag|effect|
|----|------|
|`std::regex_constants::icase`|match is case insensitive|
|`std::regex_constants::nosubs`|no matches are stored|
|`std::regex_constants::optimize`|optimize for matching speed rather than regex creation speed|
|`std::regex_constants::collate`|Character ranges of the form `[a-b]` will be locale sensitive|
|`std::regex_constants::multiline` (C++17)|`^` matches beginning of a line and `$` matches the end of a line|

---

## matching flags

|flag|effect|
|----|------|
|`std::regex_constants::match_not_bol`|`^` will not match before the first character|
|`std::regex_constants::match_not_eol`|`$` will not match after the last character|
|`std::regex_constants::match_not_bow`|`\b` will not match before the first character|
|`std::regex_constants::match_not_eow`|`\b` will not match after the last character|
|`std::regex_constants::match_any`|any match is acceptable|
|`std::regex_constants::match_not_null`|never match empty sequences|
|`std::regex_constants::match_continuous`|match should begin at first character|
|`std::regex_constants::match_prev_avail`|can refer to position before the first character|

---

## `match_prev_avail`

```cpp
///hide
#include <cassert>
#include <regex>

int main() {
///unhide
assert(not std::regex_match("ba" + 1, std::regex{"\\Ba"}));
assert(std::regex_match("ba" + 1, std::regex{"\\Ba"},
                        std::regex_constants::match_prev_avail));
///hide
}
```

---

## lazy quantifiers

adding `?` to a quantifier makes it match as little as possible

```cpp [3,6]
///hide
#include <iostream>
#include <regex>

int main() {
///unhide
std::cmatch m;
std::cout << "greedy "
          << (std::regex_search("aaaa", m, std::regex{"a{2,3}"}), m.str()) 
          << '\n';
std::cout << "lazy "
          << (std::regex_search("aaaa", m, std::regex{"a{2,3}?"}), m.str())
          << '\n';
///hide
}
```

---

## iterating matches

```cpp [10-16]
///hide
#include <regex>
#include <algorithm>
#include <iostream>

int main() {
///unhide
auto&& data = R"(
<person>
  <first>Stephen</first>
  <last>Kleene</last>
</person>
)";

std::regex r{"<(.*)>(.*)</(\\1)>"};

std::for_each(std::cregex_iterator{std::begin(data), std::end(data), r}, 
              std::cregex_iterator{},
              [](const std::cmatch& m) {
                std::cout << "match:  " << m.str() << '\n';
                std::cout << " tag:   " << m.str(1) << '\n';
                std::cout << " value: " << m.str(2) << '\n';
              });
///hide
}
```

---

## more refined iteration

```cpp [9-12]
///hide
#include <regex>
#include <algorithm>
#include <iostream>

int main() {
///unhide
auto&& data = R"(
<person>
  <first>Stephen</first>
  <last>Kleene</last>
</person>
)";

std::regex r{"<(.*)>(.*)</(\\1)>"};
std::copy(
    std::cregex_token_iterator{std::begin(data), std::end(data), r, {2}},
    std::cregex_token_iterator{},
    std::ostream_iterator<std::csub_match>(std::cout, "\n"));
///hide
}
```

---

## iterate non-matches

```cpp [3,5]
///hide
#include <regex>
#include <algorithm>
#include <iostream>

int main() {
///unhide
std::string names = "Anthony, Peter, George, David, William, Martin, Alfred";

std::regex r{R"(\s*,\s*)"};
std::copy(
    std::sregex_token_iterator{std::begin(names), std::end(names), r, {-1}},
    std::sregex_token_iterator{},
    std::ostream_iterator<std::ssub_match>(std::cout, ", "));
///hide
}
```

---

## replacing matches

```cpp [10-11]
///hide
#include <regex>
#include <algorithm>
#include <iostream>

int main() {
///unhide
auto&& data = R"(
<person>
  <first>Stephen</first>
  <last>Kleene</last>
</person>
)";

std::regex r{"<(.*)>(.*)</(\\1)>"};

std::cout << std::regex_replace(data, r, R"(<$1 value="$2"/>)") 
          << '\n';
///hide
}
```

---

## replacing matches

```cpp [10-12]
///hide
#include <regex>
#include <algorithm>
#include <iostream>

int main() {
///unhide
auto&& data = R"(
<person>
  <first>Stephen</first>
  <last>Kleene</last>
</person>
)";

std::regex r{"<(.*)>(.*)</(\\1)>"};

std::cout << std::regex_replace(data, r, R"(<\1 value="\2"/>)",
                                std::regex_constants::format_sed) 
          << '\n';
///hide
}
```

---

## replacement syntax

| |Default|sed|
|-|-------|---|
|The matched pattern|$&|&|
|The `n`th matched capture group|$n|\n|
|The prefix of the matched pattern|$‘| |
|The suffix of the matched pattern|$’| |
|The $ character|$$|$|

---

## to output iterator

```cpp [10-15]
///hide
#include <regex>
#include <algorithm>
#include <iostream>

int main() {
///unhide
auto&& data = R"(
<person>
  <first>Stephen</first>
  <last>Kleene</last>
</person>
)";

std::regex r{"<(.*)>(.*)</(\\1)>"};

std::regex_replace(std::ostream_iterator<char>(std::cout),
                   std::begin(data), std::end(data), 
                   r,
                   R"(<$1 value="$2"/>)",
                   std::regex_constants::format_no_copy | 
                   std::regex_constants::format_first_only);
///hide
}
```

Note: the passed flags make `regex_replace` to only replace the first match and output matched part only.

---

## error handling

```cpp
///compiler=clang600
///hide
#include <regex>
#include <iostream>

int main() {
///unhide
try {
  std::regex pat{"\\\\.*index\\{([^}]*)\\}",
                 std::regex_constants::grep};
}
catch (const std::regex_error& e) {
  std::cerr << "regex_error: \n"
            << " what(): " << e.what() << '\n'
            << " code(): " << e.code() << '\n';
}
///hide
}
```

---

Note: There are a couple of design decisions I personally dislike about the regex library.
a. it's not inside a namespace so you have to repeat `regex_` every second line.
b. use of output params for match
c. having to specify different match type per string type
in addition it's known for not so great runtime but nevertheless, it's available everywhere
and gets the job done eventually.

----

---

## type aliases

|`typedef`|`using`|
|---------|-------|
|`typedef std::ios_base::fmtflags flags;`|`using flags = std::ios_base::fmtflags;`|
|`typedef void (*func)(int, int);`|`using func = void (*) (int, int);`|
| - |`template<class T>`<br/>`using ptr = T*;`|
|`template<class T>`<br/>`struct add_const {`<br/>  `typedef const T type;`<br/>`};`|`template<class T>`<br/>`struct add_const {`<br/>  `using type = const T;`<br/>`};`|
|`typedef int int_t, *intp_t;`|`using int_t = int;`<br/>`using intp_t = int*;`|

---

# C++11 Containers

---

### problems with c-style arrays
#### part 1 of N

cannot be passed by value

```cpp
void func(int* x); /* this is a pointer */

void func(int x[]); /* this is a pointer */

void func(int x[10]); /* this is a pointer */
```

---

### problems with c-style arrays
#### part 2 of N

hard to get number of elements

```cpp
///hide
#include <cstddef>

///unhide
int a[17];
size_t n = sizeof(a)/sizeof(a[0]);
```

---

[![array elements](11_containers/array_elements.png)](https://www.youtube.com/watch?v=7uAwFRQkzyA&ab_channel=NDCConferences)

---

### problems with c-style arrays
#### part 3 of N

what will happen when we combine the previous slides?

```cpp
///output=2
///hide
#include <iostream>

///unhide
void func(int a[17]) {
  std::cout << sizeof(a)/sizeof(a[0]) << '\n';
}
///hide
int main() {
  int a[17];
  func(a);
}
```

---

### problems with c-style arrays
#### part 4 of N

can't be assigned to

```cpp
///fails=error: 'str' does not name a type
extern char *getpass();
char str[10];
str = getpass("Enter password: ");
```

---

### problems with c-style arrays
#### part 5 of N

hard to overload on

```cpp
///output=pointer
///hide
#include <iostream>

///unhide
void func(int*) { std::cout << "pointer\n"; }

template <size_t N>
void func(int (&) [N]) {
  std::cout << "array\n";
}

int main() {
  int arr[2];
  func(arr);
}
```

---

# `std::array`

---

## `std::array`

```cpp
///hide
#include <cstddef>

///unhide
template<typename T, size_t N>
class array;
```

Note: unlike other standard containers, there's no allocator cause `array` never allocates

---

## basic usage

```cpp
///output=1 2 3
///hide
#include <iostream>
///unhide
#include <array>

int main() {
  std::array<int, 3> arr = {1, 2, 3};
  static_assert(sizeof(arr) == 3 * sizeof(int), 
                "no space overhead");
  for(const auto& a: arr)
        std::cout << a << ' ';
  std::cout << '\n';
}
```

Note: aggregate initialization, otherwise default initialization

---

## can be passed by value

reference, pointer, cv qualified...

```cpp
///hide
#include <array>

///unhide
void func(std::array<int, 10> x);
void func(const std::array<int, 10>& x);
void func(volatile std::array<int, 10>* x);
```

---

## convenient member functions

```cpp
///hide
#include <array>
#include <cassert>

int main() {
///unhide
std::array<double, 10> arr;
assert(arr.size() == 10);
arr.fill(42.0);
assert(arr.front() == arr.back());
///hide
}
```

---

## works with legacy code

```cpp
///hide
#include <array>

///unhide
void func(int* arr, int size);

///hide
void f() {
///unhide
std::array<int, 4> arr;
func(arr.data(), arr.size());
///hide
}
```

---

## checked and unchecked element access

```cpp
///hide
#include <stdexcept>

///unhide
template<typename Cont>
auto unchecked(const Cont& cont) {
  return cont[2];
}

template<typename Cont>
auto checked(const Cont& cont) {
  try {
    cont.at(2);
  } catch (std::out_of_range& ex){
    return -1;
  }
}
```

---

## multi-dimensional is a little verbose

instead of

```cpp
int board[3][3] = {{5, 8, 2}, {8, 3, 1}, {5, 3, 9}};
```

we have

```cpp
///hide
#include <array>

///unhide
std::array<std::array<int, 3>, 3> arr = 
  {{{5, 8, 2}, {8, 3, 1}, {5, 3, 9}}};
```

---

## constructing pair

```cpp
///hide
#include <string>
#include <iostream>

///unhide
struct S {
  S(int a) {
    std::cout << "CTOR\n";
  }
  ~S() {
    std::cout << "DTOR\n";
  }
  S(S&&) {
    std::cout << "MOVE CTOR\n";
  }
};

///hide
int main() {
///unhide
std::pair<S, S> p{1, 3};
///hide
}
```

---

## constructing pair

```cpp
///fails=no matching function for call to 'std::pair<S, S>::pair(<brace-enclosed initializer list>)'
///hide
#include <string>
#include <iostream>

///unhide
struct S {
  S(int a, int b) {
    std::cout << "CTOR\n";
  }
  ~S() {
    std::cout << "DTOR\n";
  }
  S(S&&) {
    std::cout << "MOVE CTOR\n";
  }
};

///hide
int main() {
///unhide
std::pair<S, S> p{1, 2, 3, 4};
///hide
}
```

---

## constructing pair

```cpp
///hide
#include <string>
#include <iostream>

///unhide
struct S {
  S(int a, int b) {
    std::cout << "CTOR\n";
  }
  ~S() {
    std::cout << "DTOR\n";
  }
  S(S&&) {
    std::cout << "MOVE CTOR\n";
  }
};

///hide
int main() {
///unhide
std::pair<S, S> p{S{1, 2}, S{3, 4}};
///hide
}
```

---

## constructing pair

```cpp
///hide
#include <string>
#include <iostream>
#include <tuple>

///unhide
struct S {
  S(int a, int b) {
    std::cout << "CTOR\n";
  }
  ~S() {
    std::cout << "DTOR\n";
  }
  S(S&&) {
    std::cout << "MOVE CTOR\n";
  }
};

///hide
int main() {
///unhide
std::pair<S, S> p{std::piecewise_construct,
                  std::forward_as_tuple(1, 2), 
                  std::forward_as_tuple(3, 4)};
///hide
}
```

---

## hash table

![hash table](11_containers/hash.svg)

Note: Unordered associative containers—hash tables—are one of the most frequently requested additions to the standard C++ library.

As you recall, in a hash table, each key is mapped to one of `N` buckets by means of a hash function. If more than one key is mapped to the same bucket, the values are chained in a list.

When searching for keys, first the hash function is called to compute the bucket index which is then search linearly to find the matching key.
The (amortized) insertion and search times are O(1).

---

## unordered containers

---

## `std::unordered_map`

```cpp
///hide
#include <functional>
#include <memory>

///unhide
template<class Key,
         class T,
         class Hash = std::hash<Key>,
         class KeyEqual = std::equal_to<Key>,
         class Allocator = std::allocator<std::pair<const Key, T>>>
class unordered_map;
```

Note: the name isn't `hash_map` for 2 reasons:

1. `hash_map`s were already in use when this was standardized but might had small differences so defining a standard class with that name would introduce a nasty backward compatibility problem.
2. These names alert users to the most important way in which (say) `unordered_map` differs from `map`: the former lacks the latter's ordering guarantee.

---

## basic usage

```cpp [1|3-7|9-10]
///output=The HEX of color BLACK is:[]
///hide
#include <iostream>
#include <string>
///unhide
#include <unordered_map>

///hide
int main() {
///unhide
std::unordered_map<std::string, std::string> u = {
  {"RED","#FF0000"},
  {"GREEN","#00FF00"},
  {"BLUE","#0000FF"}
};

std::cout << "The HEX of color RED is:[" << u["RED"] << "]\n";
std::cout << "The HEX of color BLACK is:[" << u["BLACK"] << "]\n";
///hide
}
```

Note: There is no specialization for C strings. `std::hash<const char*>` produces a hash of the value of the pointer.

---

## insertion

```cpp [9-12]
///output=The HEX of color BLACK is:[#000000]
///hide
#include <iostream>
#include <string>
///unhide
#include <unordered_map>

///hide
int main() {
///unhide
std::unordered_map<std::string, std::string> u = {
  {"RED","#FF0000"},
  {"GREEN","#00FF00"},
  {"BLUE","#0000FF"}
};

u.emplace("BLACK", "#000000");

std::cout << "The HEX of color RED is:[" << u["RED"] << "]\n";
std::cout << "The HEX of color BLACK is:[" << u["BLACK"] << "]\n";
///hide
}
```

Note: to insert elements, it's best to call `emplace` which constructs the value in place.

---

## insertion

```cpp [9-15]
///output=The HEX of color BLACK is:[#000000]
///hide
#include <iostream>
#include <string>
#include <tuple>
#include <cstring>
///unhide
#include <unordered_map>

///hide
int main() {
///unhide
std::unordered_map<std::string, std::string> u = {
  {"RED","#FF0000"},
  {"GREEN","#00FF00"},
  {"BLUE","#0000FF"}
};

char black[] = "#000000";
u.emplace(std::piecewise_construct, 
          std::forward_as_tuple("BLACK"), 
          std::forward_as_tuple(black, strlen(black)));

std::cout << "The HEX of color RED is:[" << u["RED"] << "]\n";
std::cout << "The HEX of color BLACK is:[" << u["BLACK"] << "]\n";
///hide
}
```

---

## checked

```cpp [9-14]
///external
///output=_Map_base::at
///compiler=clang600
///hide
#include <iostream>
#include <string>
///unhide
#include <unordered_map>

///hide
int main() {
///unhide
std::unordered_map<std::string, std::string> u = {
  {"RED","#FF0000"},
  {"GREEN","#00FF00"},
  {"BLUE","#0000FF"}
};

try {
  std::cout << "The HEX of color RED is:[" << u.at("RED") << "]\n";
  std::cout << "The HEX of color BLACK is:[" << u.at("BLACK") << "]\n";
} catch (std::out_of_range& ex){
  std::cerr << ex.what() << "\n";
}
///hide
}
```

---

## find

```cpp [9-15]
///output=The HEX of color RED is:[#FF0000]
///hide
#include <iostream>
#include <string>
///unhide
#include <unordered_map>

///hide
int main() {
///unhide
std::unordered_map<std::string, std::string> u = {
  {"RED","#FF0000"},
  {"GREEN","#00FF00"},
  {"BLUE","#0000FF"}
};

for (const auto& key : {"RED", "BLACK"}) {
  auto it = u.find(key);
  if (it != u.end()) {
    std::cout << "The HEX of color " << key 
              << " is:[" << it->second << "]\n";
  }
}
///hide
}
```

---

## iterating

```cpp [9-13]
///hide
#include <iostream>
#include <string>
///unhide
#include <unordered_map>

///hide
int main() {
///unhide
std::unordered_map<std::string, std::string> u = {
  {"RED","#FF0000"},
  {"GREEN","#00FF00"},
  {"BLUE","#0000FF"}
};

for (const auto& n : u) {
  std::cout << "Key:[" << n.first 
            << "] Value:[" << n.second 
            << "]\n";
}
///hide
}
```

---

## erasing

```cpp [9-17]
///hide
#include <cassert>
#include <string>
///unhide
#include <unordered_map>

///hide
int main() {
///unhide
std::unordered_map<std::string, std::string> u = {
  {"RED","#FF0000"},
  {"GREEN","#00FF00"},
  {"BLUE","#0000FF"}
};

for (auto it = u.begin(); it != u.end();) {
  if (it->second.substr(1, 2) == "00") {
    it = u.erase(it);
  } else {
    ++it;
  }
}

assert(u.size() == 1);
///hide
}
```

Note: unordered containers provide forward iterators.

---

## load factor

|a|b|
|-|-|
| `$$ loadFactor = \frac{occupied}{buckets} $$` | ![hash table](11_containers/hash.svg)  |

Note: in the example load factor is 5/255 ~ 0.02.

A hash table is resized when its load factor goes beyond a predefined threshold.

After resizing, the table is rehashed - all elements' hashes are recomputed and they're moved to their new location.

---

## managing load factor

```cpp [5-7|9|11-12]
///hide
#include <unordered_map>
#include <cassert>
#include <limits>
#include <cmath>

///unhide
bool approxEqual(float a, float b) {
  return std::abs(a - b) < std::numeric_limits<float>::epsilon();
}

///hide
int main() {
///unhide
std::unordered_map<int, double> um;
assert(um.load_factor() == 0.0);
assert(um.max_load_factor() == 1.0);

um.max_load_factor(0.7);

um.emplace(2, -2.5);
assert(approxEqual(um.load_factor(), 1.0 / um.bucket_count()));
///hide
}
```

---

## be prepared

```cpp []
///hide
#include <unordered_map>
#include <cassert>

int main() {
///unhide
using map = std::unordered_map<int, double>;
map um{100};    // start with 100 buckets
// ...
um.rehash(50);  // prepare for 50/max_load_factor() elements
// ...
um.reserve(200); // prepare for 200 elements
///hide
}
```

Note: before time critical sections, it's advised to prepare the hash table to the expected number of elements to be inserted so expensive rehashes won't occur when its least appropriate.

---

## `std::hash`

```cpp
///hide
#include <cstdint>

///unhide
template<class Key>
struct hash {
  std::size_t operator()(const Key&) const;
};
```

Note: as the number of buckets is less than `std::numeric_limits<size_t>::max()`, the container will need to map the return value to a bucket number, e.g. by taking the result modulo the number of buckets.

---

## standard provided hashing

- all integral types
- all floating-point types
- pointers
- strings
- some library types, like
  - `std::unique_ptr`
  - `std::bitset`

---

## writing hash functions

is difficult™

---

## writing hash functions

using boost

```cpp
///external
///libs=boost:173
///hide
#include <string>
#include <vector>
#include <unordered_set>
///unhide
#include <boost/container_hash/hash.hpp>

struct S {
  int a;
  double d;
  std::vector<std::string> v;
};

namespace std {
  template<> struct hash<S> {
    size_t operator()(const S& s) const {
        std::size_t seed = 0;
        boost::hash_combine(seed, s.a);
        boost::hash_combine(seed, s.d);
        boost::hash_range(seed, s.v.begin(), s.v.end());
        return seed;
    }
  };
}
///hide

std::unordered_set<S> us;
```

---

## accessing bucket structure

```cpp [1-2,10|3-4,8-9|5-7|12-16]
///output=bucket[1]: 8->7 1->2
///compiler=g83
///hide
#include <iostream>
#include <unordered_map>
#include <algorithm>

///unhide
template<typename Key, typename Val>
void printTable(const std::unordered_map<Key, Val>& um) {
  for(size_t i = 0; i < um.bucket_count(); ++i) {
    std::cout << "bucket[" << i << "]: ";
    for (auto it = um.begin(i); it != um.end(i); ++it) {
      std::cout << it->first << "->" << it->second << " ";
    }
    std::cout << '\n';
  }
}

int main() {
  std::unordered_map<int, int> um{
    {1, 2}, {5, 6}, {7, 8}, {9, 10}, {8, 7}
  };
  printTable(um);
}
```

Note: Can be useful to debug your hash functions

---

## other unordered containers

- `<unordered_map>`
  - `std::unordered_multimap`
- `<unordered_set>`
  - `std::unordered_set`
  - `std::unordered_multiset`

---

## `std::list` overhead

```cpp
///external
///options+=-fsanitize=address
///fails=AddressSanitizer: 2424 byte(s) leaked in 101 allocation(s)
#include <list>

int main() {
  new std::list<int>(100);
}
```

---

# `std::forward_list`

---

## `std::forward_list`

```cpp
///hide
#include <memory>

///unhide
template<class T,
         class Allocator = std::allocator<T>> 
class forward_list;
```

---

## less overhead

```cpp
///external
///options+=-fsanitize=address
///fails=AddressSanitizer: 1608 byte(s) leaked in 101 allocation(s)
#include <forward_list>

int main() {
  new std::forward_list<int>(100);
}
```

---

---

---

---

---

## insertion

```cpp [17-19|20-25]
///hide
#include <forward_list>
#include <iostream>
#include <string>
 
///unhide
struct Sum {
  std::string remark;
  int sum;

Sum(std::string remark, int sum)
    : remark{std::move(remark)}, sum{sum} {}

void print() const {
    std::cout << remark << " = " << sum << '\n';
  }
};

int main()
{
  std::forward_list<Sum> list;

auto iter = list.before_begin();
  std::string str{"1"};
  for (int i{1}, sum{1}; i != 10; sum += i) {
      iter = list.emplace_after(iter, str, sum);
      ++i;
      str += " + " + std::to_string(i);
  }

for (const Sum& s : list) s.print();
}
```

---

## at front

```cpp
///hide
#include <forward_list>
#include <cassert>
int main ()
{
///unhide
std::forward_list<int> mylist{1, 2};
mylist.push_front(3);
mylist.emplace_front(4);
mylist.pop_front();
assert(mylist.front() == 3);
///hide
}
```

---

## algorithms

```cpp [9-17]
///hide
#include <iostream>
#include <forward_list>

///unhide
std::ostream& operator<<(std::ostream& ostr, 
                         const std::forward_list<int>& list) {
  for (auto &i : list) {
    ostr << " " << i;
  }
  return ostr;
}

///hide
int main() {
///unhide
std::forward_list<int> list1 = { 5,9,0,1,3 };
std::forward_list<int> list2 = { 8,7,2,6,4 };

list1.sort();
list2.sort();
std::cout << "list1:  " << list1 << "\n";
std::cout << "list2:  " << list2 << "\n";
list1.merge(list2);
std::cout << "merged: " << list1 << "\n";
///hide
}
```

---

## thank you

----

---

## c-style

```cpp
///hide
#include <cstdlib>
#include <ctime>
#include <iostream>

void foo() {
///unhide
std::srand(std::time(nullptr));

for (size_t _ = 0; _ < 1'000; ++_) {
    std::cout << std::rand() % 100'000 << '\n';
}
///hide
}
```

---

## what's wrong?

1.   seed in seconds
2.   non-uniform distribution
3.   <code>RAND_MAX</code>
4.   might not be thread safe

Note: 
1. Imagine our application runs in a grid. There's a likely chance two instances will start on the same second.
2. Assuming range is not divisible by the modulus without a remainder
3. can be as low as 32767
4. this is implementation defined

---

## Pseudo-random number generation

Sources:

- [N3551](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3551.pdf), Walter E. Brown
- [N1398](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1398.html), Jens Maurer

</div>

---

## why?

- numerics (simulation, Monte-Carlo integration)
- games (shuffling card decks, non-deterministic enemy behavior)
- testing (generation of test input data for good coverage)
- security (generation of cryptographic keys)

Note: Computers are deterministic machines by design: equal input data results in equal output, given the same internal state. Sometimes, applications require seemingly non-deterministic behavior, usually provided by generating random numbers.

---

## generating pseudo randomness

![generating random](12_random/generating_random.svg)

Note: We start with some seed data as an entropy source. This is used to initialize an engine which is a function object which upon call, generates a pseudo-random number and updates its internal state. The distribution post-processes the engine's output in such a way that resulting output is distributed according to a defined statistical probability density function.

---

## dice rolling

```cpp
///hide
#include <iostream>
///unhide
#include <random>

int roll_a_fair_die( ) {
  static unsigned seed{0x12345678};
  static std::default_random_engine e{seed};
  static std::uniform_int_distribution<int> d{1, 6};
  return d(e);
}
///hide

int main() {
  for (size_t i = 0; i < 20; ++i) {
      std::cout << roll_a_fair_die() << ' ';
  }
  std::cout << '\n';
}
```

---

## engines

Note: An engine’s role is to return unpredictable (random) bits, ensuring that the likelihood of
next obtaining a 0 bit is always the same as the likelihood of next obtaining a 1 bit. 
To reduce overhead and improve throughput, C++ engines typically compute and return many bits per call by
encoding them into a single result of an unsigned integer type.

---

## what can it do

```cpp [1|3-5|7-16]
///hide
#include <random>
#include <iostream>
#include <cassert>
#include <sstream>

int main() {
///unhide
std::default_random_engine e;

std::cout << "e's range is [" 
          << e.min() << "," 
          << e.max() << "]\n";

std::stringstream sst;
sst << e;
const auto n1 = e();

e.seed(42);
e.discard(10);

sst >> e;
const auto n2 = e();
assert(n1 == n2);
///hide
}
```

Note: 
1. default constructible with some default seed
2. generates values between `min` and `max`
3. can be serialized/deserialized to an `iostream`
4. can be called directly
5. can be reseeded
6. results can be discarded

---

## Library engines

beyond `std::default_random_engine`.

Note: it is actually an alias to one of several library defined engines.

---

## Linear congruential generator (LCG)

`$$ X_{n+1} = \left( a X_n + c \right)\bmod m $$`

for some predefined `a`, `c` and `m`.

Note: of course, not every choice of parameters will generate a pseudo-random sequence. for example, a = 1 and c = 1 produces a simple modulo-m counter, but there are parameters which were found to produce series of high quality.

---

## LCG

```cpp
template <class UIntType, 
          UIntType a, UIntType c, UIntType m>
class linear_congruential_engine;
```

---

## predefined

## LCG

```cpp
///hide
#include <cstdint>

///unhide
template <class UIntType, 
          UIntType a, UIntType c, UIntType m>
class linear_congruential_engine;

using minstd_rand0 =
    linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>;

using minstd_rand =
    linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>;
```

---

## Subtract with carry (SWC)

`$$ x_i = (x_{i-s} - x_{i-r} - c_{i-1})\ \bmod\ m $$`

where

`$$
c_i = \begin{cases}
    1, & \text{if } x_{i-s} - x{i-r} - c_{i-1} < 0\\
    0, & \text{otherwise}
\end{cases}
$$`

---

## SWC

```cpp
///hide
#include <cstddef>

///unhide
template<class UIntType,
         size_t w, size_t s, size_t r> 
class subtract_with_carry_engine;
```

---

## predefined

## SWC

```cpp
///hide
#include <cstddef>
#include <cstdint>

///unhide
template<class UIntType,
         size_t w, size_t s, size_t r> 
class subtract_with_carry_engine;

using ranlux24_base 
  = subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>;

using ranlux48_base 
  = subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>;
```

Note: ranlux is the name of the Fortran library which was the first implementation of this RNG.

---

## mersenne twister (MT)

`$$ x_{k+n} := x_{k+m} \oplus \left( ({x_k}^u \mid\mid {x_{k+1}}^l) A \right) \qquad k=0,1,\ldots $$`

where

`$$ A = \begin{pmatrix} 0 & I_{w - 1} \\ a_{w-1} & (a_{w - 2}, \ldots , a_0) \end{pmatrix} $$`

Note: This is a form of a shift register. `||` denotes concatenation of bit vectors, `^u` means the upper `w - r` bits, and `^l` means the lower `r` bits.

---

## mersenne twister (MT)

on state `x` the engine's output will be

```cpp
///hide
#include <cstdint>

uint32_t calc(uint32_t x, uint32_t u, uint32_t s, uint32_t t, uint32_t d, uint32_t b, uint32_t c, uint32_t l) {
///unhide
auto y = x ^ ((x >> u) & d);
     y = y ^ ((y << s) & b);
     y = y ^ ((y << t) & c);
auto z = y ^ (y >> l);

return z;
///hide
}
```

for some predefined parameters `u`, `s`, `t`, `d`, `b`, `c` and `l`.

---

## MT

```cpp
///hide
#include <cstddef>

///unhide
template <class UIntType, size_t w, size_t n, size_t m, size_t r, UIntType a,
          size_t u, UIntType d, size_t s, UIntType b, size_t t, UIntType c,
          size_t l, UIntType f>
class mersenne_twister_engine;
```

---

## predefined

## MT

```cpp
///hide
#include <cstddef>
#include <cstdint>

using mt19937 =
    mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31, 0x9908b0df,
                            11, 0xffffffff, 7, 0x9d2c5680, 15, 0xefc60000, 18,
                            1812433253>;

using mt19937_64 =
    mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
                            0xb5026f5aa96619e9, 29, 0x5555555555555555, 17,
                            0x71d67fffeda60000, 37, 0xfff7eee000000000, 43,
                            6364136223846793005>;
```

Note: the period of those engines is `2^19937 − 1`

---

## engine adaptors

generate pseudo-random numbers using another random number engine as entropy source.

---

## `discard_block_engine`

```cpp
///hide
#include <cstddef>

///unhide
template <class Engine,
          size_t P, size_t R> 
class discard_block_engine;
```

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
   xmlns:osb="http://www.openswatchbook.org/uri/2009/osb"
   xmlns:dc="http://purl.org/dc/elements/1.1/"
   xmlns:cc="http://creativecommons.org/ns#"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   sodipodi:docname="discard.svg"
   inkscape:version="1.0 (4035a4f, 2020-05-01)"
   id="svg2080"
   version="1.1"
   viewBox="0 0 921.44445 20.310083"
   height="20.310083mm"
   width="195.03908mm"
   class="animated">
  <defs
     id="defs2074">
    <linearGradient
       id="linearGradient3355"
       osb:paint="solid">
      <stop
         style="stop-color:#0000ff;stop-opacity:1;"
         offset="0"
         id="stop3353" />
    </linearGradient>
    <inkscape:path-effect
       effect="bspline"
       id="path-effect909"
       is_visible="true"
       lpeversion="1"
       weight="33.333333"
       steps="2"
       helper_size="0"
       apply_no_weight="true"
       apply_with_weight="true"
       only_selected="false" />
    <inkscape:path-effect
       only_selected="false"
       apply_with_weight="true"
       apply_no_weight="true"
       helper_size="0"
       steps="2"
       weight="33.333333"
       lpeversion="1"
       is_visible="true"
       id="path-effect2849"
       effect="bspline" />
    <inkscape:path-effect
       only_selected="false"
       apply_with_weight="true"
       apply_no_weight="true"
       helper_size="0"
       steps="2"
       weight="33.333333"
       lpeversion="1"
       is_visible="true"
       id="path-effect2845"
       effect="bspline" />
    <rect
       id="rect2647"
       height="21.960417"
       width="23.547916"
       y="117.21042"
       x="25.4" />
    <rect
       x="25.4"
       y="117.21042"
       width="23.547916"
       height="21.960417"
       id="rect2835" />
    <rect
       id="rect2841"
       height="21.960417"
       width="23.547916"
       y="117.21042"
       x="25.4" />
  </defs>
  <sodipodi:namedview
     inkscape:window-maximized="0"
     inkscape:window-y="23"
     inkscape:window-x="0"
     inkscape:window-height="1005"
     inkscape:window-width="1680"
     fit-margin-bottom="0"
     fit-margin-right="0"
     fit-margin-left="0"
     fit-margin-top="0"
     showgrid="false"
     inkscape:document-rotation="0"
     inkscape:current-layer="layer1"
     inkscape:document-units="mm"
     inkscape:cy="31.360262"
     inkscape:cx="85.743066"
     inkscape:zoom="3.4055229"
     inkscape:pageshadow="2"
     inkscape:pageopacity="0.0"
     borderopacity="1.0"
     bordercolor="#666666"
     pagecolor="#ffffff"
     id="base" />
  <metadata
     id="metadata2077">
    <rdf:RDF>
      <cc:Work
         rdf:about="">
        <dc:format>image/svg+xml</dc:format>
        <dc:type
           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
        <dc:title></dc:title>
      </cc:Work>
    </rdf:RDF>
  </metadata>
  <g
     transform="translate(-16.063988,-144.59981)"
     id="layer1"
     inkscape:groupmode="layer"
     inkscape:label="Layer 1">
    <rect
       y="109.75485"
       x="19.040558"
       height="90"
       width="90"
       id="rect2643"
       style="fill:none;stroke:#ff5555;stroke-width:1.72125;stop-color:#000000" />
    <rect
       style="fill:#bee4fd;fill-opacity:1;stroke:#3e4837;stroke-width:5.95314;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="rect2704"
       width="90"
       height="90"
       x="19.040558"
       y="109.75485" />
    <g
       aria-label="0"
       id="text2708"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
       transform="matrix(2.25,0,0,2.25,-20.079982,-133.47285)">
      <path
         d="m 39.8708,128.096 c 0,1.29 -0.2026,2.237 -0.6077,2.841 -0.4019,0.601 -1.0273,0.902 -1.8762,0.902 -0.8617,0 -1.492,-0.305 -1.8907,-0.916 -0.3955,-0.611 -0.5932,-1.55 -0.5932,-2.817 0,-1.277 0.201,-2.219 0.6029,-2.826 0.4019,-0.611 1.0289,-0.917 1.881,-0.917 0.8617,0 1.4904,0.311 1.8859,0.931 0.3987,0.617 0.598,1.552 0.598,2.802 z m -1.2685,2.19 c 0.1126,-0.26 0.1881,-0.566 0.2267,-0.916 0.0418,-0.354 0.0627,-0.778 0.0627,-1.274 0,-0.488 -0.0209,-0.913 -0.0627,-1.273 -0.0386,-0.36 -0.1157,-0.666 -0.2315,-0.916 -0.1125,-0.248 -0.2669,-0.434 -0.463,-0.56 -0.1929,-0.125 -0.4421,-0.188 -0.7476,-0.188 -0.3022,0 -0.553,0.063 -0.7524,0.188 -0.1961,0.126 -0.3521,0.315 -0.4678,0.569 -0.1094,0.238 -0.1849,0.549 -0.2267,0.931 -0.0386,0.383 -0.0579,0.802 -0.0579,1.259 0,0.502 0.0177,0.921 0.053,1.259 0.0354,0.337 0.111,0.64 0.2267,0.907 0.1061,0.25 0.2557,0.442 0.4486,0.574 0.1961,0.131 0.455,0.197 0.7765,0.197 0.3023,0 0.5531,-0.062 0.7524,-0.188 0.1994,-0.125 0.3537,-0.315 0.463,-0.569 z"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
         id="path3657" />
    </g>
    <rect
       style="fill:#bee4fd;fill-opacity:1;stroke:#3e4837;stroke-width:5.95314;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="rect2712"
       width="90"
       height="90"
       x="110.7618"
       y="109.75485" />
    <g
       aria-label="1"
       id="text2716"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
       transform="matrix(2.25,0,0,2.25,-20.079982,-133.47285)">
      <path
         d="m 80.0957,131.704 h -3.8875 v -0.733 h 1.4952 v -4.814 h -1.4952 v -0.655 c 0.2026,0 0.4196,-0.017 0.6511,-0.049 0.2316,-0.035 0.4068,-0.085 0.5258,-0.149 0.1479,-0.081 0.2636,-0.182 0.3472,-0.304 0.0868,-0.125 0.1367,-0.293 0.1496,-0.502 h 0.7475 v 6.473 h 1.4663 z"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
         id="path3660" />
    </g>
    <rect
       style="fill:#bee4fd;fill-opacity:1;stroke:#3e4837;stroke-width:5.95314;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="rect2720"
       width="90"
       height="90"
       x="202.48308"
       y="109.75485" />
    <g
       aria-label="2"
       id="text2724"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
       transform="matrix(2.25,0,0,2.25,-20.079982,-133.47285)">
      <path
         d="m 121.348,131.767 h -4.862 v -1.008 c 0.338,-0.29 0.675,-0.579 1.013,-0.868 0.341,-0.29 0.657,-0.578 0.95,-0.864 0.617,-0.598 1.04,-1.072 1.269,-1.423 0.228,-0.353 0.342,-0.734 0.342,-1.143 0,-0.373 -0.124,-0.664 -0.371,-0.873 -0.245,-0.212 -0.587,-0.318 -1.028,-0.318 -0.292,0 -0.609,0.051 -0.95,0.154 -0.341,0.103 -0.674,0.261 -0.998,0.473 h -0.049 v -1.013 c 0.229,-0.112 0.533,-0.215 0.912,-0.309 0.383,-0.093 0.752,-0.139 1.109,-0.139 0.737,0 1.314,0.178 1.732,0.535 0.418,0.354 0.627,0.834 0.627,1.442 0,0.273 -0.035,0.529 -0.106,0.767 -0.068,0.235 -0.169,0.458 -0.304,0.67 -0.125,0.2 -0.273,0.396 -0.444,0.589 -0.167,0.193 -0.371,0.407 -0.612,0.641 -0.344,0.338 -0.7,0.666 -1.066,0.984 -0.367,0.315 -0.709,0.608 -1.028,0.878 h 3.864 z"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
         id="path3663" />
    </g>
    <rect
       style="fill:#bee4fd;fill-opacity:1;stroke:#3e4837;stroke-width:5.95314;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="rect2728"
       width="90"
       height="90"
       x="294.20428"
       y="109.75485" />
    <rect
       style="fill:#bee4fd;fill-opacity:1;stroke:#3e4837;stroke-width:5.95314;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="rect2736"
       width="90"
       height="90"
       x="385.92554"
       y="109.75485" />
    <path
       id="rect2744"
       style="fill:#bee4fd;fill-opacity:1;stroke:#3e4837;stroke-width:5.95311;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       d="m 477.64682,109.75485 h 90 v 90 h -90 z" />
    <rect
       style="fill:#bee4fd;fill-opacity:1;stroke:#3e4837;stroke-width:5.95314;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="rect2752"
       width="90"
       height="90"
       x="569.3681"
       y="109.75485" />
    <g
       aria-label="R"
       id="text2756"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
       transform="matrix(2.25,0,0,2.25,-20.079982,-133.47285)">
      <path
         d="m 284.948,131.692 h -1.239 l -2.402,-2.855 h -1.346 v 2.855 h -0.955 v -7.182 h 2.011 c 0.434,0 0.796,0.029 1.085,0.087 0.29,0.055 0.55,0.155 0.782,0.299 0.26,0.164 0.463,0.372 0.608,0.622 0.147,0.248 0.221,0.563 0.221,0.946 0,0.517 -0.13,0.951 -0.39,1.302 -0.261,0.347 -0.619,0.609 -1.076,0.786 z m -2.233,-5.161 c 0,-0.206 -0.037,-0.387 -0.111,-0.545 -0.071,-0.161 -0.19,-0.296 -0.357,-0.405 -0.138,-0.093 -0.302,-0.157 -0.492,-0.193 -0.19,-0.038 -0.413,-0.058 -0.67,-0.058 h -1.124 v 2.711 h 0.965 c 0.302,0 0.566,-0.026 0.791,-0.077 0.225,-0.055 0.416,-0.155 0.574,-0.299 0.144,-0.135 0.25,-0.29 0.318,-0.463 0.071,-0.177 0.106,-0.401 0.106,-0.671 z"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
         id="path3673" />
    </g>
    <g
       aria-label="…"
       id="text2833"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2835);fill:#000000;fill-opacity:1;stroke:none"
       transform="matrix(2.25,0,0,2.25,-20.079982,-133.47285)">
      <path
         d="m 244.395,128.639 h -0.983 v -1.076 h 0.983 z m -2.691,0 h -0.984 v -1.076 h 0.984 z m -2.691,0 h -0.984 v -1.076 h 0.984 z"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
         id="path3771" />
    </g>
    <g
       aria-label="…"
       id="text2839"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2841);fill:#000000;fill-opacity:1;stroke:none"
       transform="matrix(2.25,0,0,2.25,-20.079982,-133.47285)">
      <path
         d="m 203.63,128.639 h -0.983 v -1.076 h 0.983 z m -2.691,0 h -0.984 v -1.076 h 0.984 z m -2.691,0 h -0.984 v -1.076 h 0.984 z"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
         id="path3667" />
    </g>
    <g
       transform="matrix(3,0,0,3,-32.127974,-213.55656)"
       class="disappear"
       style="animation-delay: 3s"
       id="g1116">
      <g
         id="g3899">
        <rect
           style="fill:#bee4fd;fill-opacity:1;stroke:#3e4837;stroke-width:1.98438;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
           id="rect2760"
           width="30"
           height="30"
           x="231.07243"
           y="107.77047" />
        <g
           aria-label="R+1"
           id="text2764"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
           transform="matrix(0.75,0,0,0.75,4.0159973,26.69457)">
          <path
             d="m 319.076,131.704 h -1.239 l -2.402,-2.855 h -1.346 v 2.855 h -0.955 v -7.182 h 2.011 c 0.434,0 0.796,0.029 1.085,0.087 0.29,0.055 0.55,0.155 0.782,0.299 0.26,0.164 0.463,0.372 0.608,0.622 0.147,0.248 0.221,0.563 0.221,0.946 0,0.517 -0.13,0.952 -0.39,1.302 -0.261,0.347 -0.619,0.609 -1.076,0.786 z m -2.233,-5.161 c 0,-0.205 -0.037,-0.387 -0.111,-0.545 -0.071,-0.16 -0.19,-0.296 -0.357,-0.405 -0.138,-0.093 -0.302,-0.157 -0.492,-0.193 -0.19,-0.038 -0.413,-0.058 -0.67,-0.058 h -1.124 v 2.711 h 0.965 c 0.302,0 0.566,-0.026 0.791,-0.077 0.225,-0.055 0.416,-0.155 0.574,-0.299 0.144,-0.135 0.25,-0.29 0.318,-0.463 0.071,-0.177 0.106,-0.401 0.106,-0.671 z"
             style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
             id="path3676" />
          <path
             d="m 326.108,128.945 h -2.628 v 2.629 h -0.801 v -2.629 h -2.629 v -0.771 h 2.629 v -2.629 h 0.801 v 2.629 h 2.628 z"
             style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
             id="path3678" />
          <path
             d="m 332.349,131.704 h -3.887 v -0.733 h 1.495 v -4.814 h -1.495 v -0.655 c 0.203,0 0.42,-0.017 0.651,-0.049 0.232,-0.035 0.407,-0.085 0.526,-0.149 0.148,-0.081 0.263,-0.182 0.347,-0.304 0.087,-0.125 0.137,-0.293 0.15,-0.502 h 0.747 v 6.473 h 1.466 z"
             style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
             id="path3680" />
        </g>
      </g>
      <g
         id="g3892">
        <rect
           style="fill:#bee4fd;fill-opacity:1;stroke:#3e4837;stroke-width:1.98438;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
           id="rect2768"
           width="30"
           height="30"
           x="261.64618"
           y="107.77047" />
        <g
           aria-label="…"
           id="text2772"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
           transform="matrix(0.75,0,0,0.75,4.0159973,26.69457)">
          <path
             d="m 366.69,128.639 h -0.983 v -1.076 h 0.983 z m -2.691,0 h -0.984 v -1.076 h 0.984 z m -2.691,0 h -0.984 v -1.076 h 0.984 z"
             style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
             id="path3683" />
        </g>
      </g>
      <g
         id="g3887">
        <rect
           style="fill:#bee4fd;fill-opacity:1;stroke:#3e4837;stroke-width:1.98438;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
           id="rect2776"
           width="30"
           height="30"
           x="292.21994"
           y="107.77047" />
        <g
           aria-label="P"
           id="text2780"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
           transform="matrix(0.75,0,0,0.75,4.0159973,26.69457)">
          <path
             d="m 406.621,126.681 c 0,0.318 -0.057,0.614 -0.169,0.887 -0.109,0.27 -0.264,0.505 -0.463,0.704 -0.248,0.248 -0.54,0.434 -0.878,0.56 -0.338,0.122 -0.764,0.183 -1.278,0.183 h -0.955 v 2.677 h -0.955 v -7.182 h 1.949 c 0.43,0 0.795,0.037 1.094,0.111 0.299,0.071 0.565,0.184 0.796,0.338 0.274,0.183 0.484,0.411 0.632,0.685 0.151,0.273 0.227,0.619 0.227,1.037 z m -0.994,0.024 c 0,-0.248 -0.043,-0.463 -0.13,-0.646 -0.087,-0.184 -0.219,-0.333 -0.396,-0.449 -0.154,-0.1 -0.331,-0.17 -0.53,-0.212 -0.196,-0.045 -0.445,-0.068 -0.748,-0.068 h -0.945 v 2.87 h 0.805 c 0.386,0 0.7,-0.034 0.941,-0.101 0.241,-0.071 0.437,-0.182 0.588,-0.333 0.152,-0.154 0.258,-0.317 0.319,-0.487 0.064,-0.171 0.096,-0.362 0.096,-0.574 z"
             style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
             id="path3768" />
        </g>
        <g
           id="g2852"
           style="fill:#cccccc;stroke:#000000;stroke-width:0;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
           transform="matrix(0.75,0,0,0.75,4.0159973,26.69457)">
          <path
             style="fill:#cccccc;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
             d="m 424.27192,108.1012 c 0,0 -40.76499,40 -40.76499,40"
             id="path2843">
            <path
               id="path2847"
               d="m 383.50693,108.1012 c 0,0 40.76499,40 40.76499,40"
               style="fill:#cccccc;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1;stroke-miterlimit:4;stroke-dasharray:none" />
          </path>
        </g>
        <path
           style="fill:#cccccc;stroke:#000000;stroke-width:0;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
           d="m 292.21994,107.77047 c 10.00019,10.0002 20.00019,20.0002 30,30"
           id="path907" />
      </g>
    </g>
    <g
       aria-label="3"
       id="text1144"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.33333px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect1146)"
       transform="matrix(3,0,0,3,-32.128214,-213.55665)">
      <path
         d="m 125.326,122.882 c 0.13,0.117 0.237,0.263 0.321,0.44 0.084,0.176 0.126,0.404 0.126,0.683 0,0.277 -0.05,0.531 -0.15,0.761 -0.101,0.231 -0.242,0.432 -0.424,0.603 -0.203,0.189 -0.443,0.33 -0.72,0.423 -0.274,0.089 -0.575,0.134 -0.903,0.134 -0.336,0 -0.667,-0.041 -0.993,-0.122 -0.325,-0.079 -0.593,-0.166 -0.801,-0.261 v -0.85 h 0.061 c 0.23,0.152 0.501,0.278 0.813,0.378 0.312,0.101 0.613,0.151 0.904,0.151 0.171,0 0.352,-0.028 0.545,-0.085 0.193,-0.057 0.349,-0.141 0.468,-0.253 0.125,-0.119 0.217,-0.251 0.277,-0.394 0.062,-0.144 0.093,-0.326 0.093,-0.546 0,-0.217 -0.035,-0.396 -0.106,-0.537 -0.067,-0.144 -0.162,-0.256 -0.284,-0.337 -0.123,-0.085 -0.27,-0.142 -0.444,-0.171 -0.174,-0.033 -0.361,-0.049 -0.562,-0.049 h -0.366 v -0.676 h 0.285 c 0.412,0 0.741,-0.085 0.985,-0.256 0.247,-0.174 0.37,-0.426 0.37,-0.757 0,-0.146 -0.031,-0.274 -0.094,-0.382 -0.062,-0.112 -0.149,-0.202 -0.26,-0.273 -0.117,-0.07 -0.241,-0.119 -0.374,-0.146 -0.133,-0.028 -0.284,-0.041 -0.452,-0.041 -0.258,0 -0.532,0.046 -0.822,0.138 -0.29,0.092 -0.564,0.223 -0.822,0.391 h -0.041 v -0.851 c 0.193,-0.095 0.449,-0.181 0.77,-0.26 0.322,-0.081 0.634,-0.122 0.935,-0.122 0.296,0 0.557,0.027 0.782,0.081 0.225,0.055 0.428,0.141 0.61,0.261 0.195,0.13 0.343,0.287 0.444,0.472 0.1,0.184 0.15,0.4 0.15,0.647 0,0.336 -0.119,0.63 -0.358,0.883 -0.236,0.249 -0.515,0.407 -0.838,0.472 v 0.057 c 0.13,0.021 0.279,0.067 0.447,0.138 0.169,0.068 0.311,0.153 0.428,0.256 z"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.33333px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
         id="path1176" />
    </g>
  </g>
</svg>

Note: From each block of size P generated by the base engine, the adaptor keeps only R numbers, discarding the rest.

---

## predefined

## `discard_block_engine`

```cpp
///hide
#include <cstddef>
#include <cstdint>

template<class UIntType,
         size_t w, size_t s, size_t r> 
class subtract_with_carry_engine;

using ranlux24_base 
  = subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>;

using ranlux48_base 
  = subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>;

///unhide
template <class Engine,
          size_t P, size_t R> 
class discard_block_engine;

using ranlux24 
  = discard_block_engine<ranlux24_base, 223, 23>;

using ranlux48 
  = discard_block_engine<ranlux48_base, 389, 11>;
```

---

## `shuffle_order_engine`

```cpp
///hide
#include <cstddef>

///unhide
template<class Engine,
         std::size_t K> 
class shuffle_order_engine;
```

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
   xmlns:osb="http://www.openswatchbook.org/uri/2009/osb"
   xmlns:dc="http://purl.org/dc/elements/1.1/"
   xmlns:cc="http://creativecommons.org/ns#"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   class="animated"
   width="195.03908mm"
   height="20.310081mm"
   viewBox="0 0 921.44446 20.310081"
   version="1.1"
   id="svg2080"
   inkscape:version="1.0 (4035a4f, 2020-05-01)"
   sodipodi:docname="shuffle_pre.svg">
  <defs
     id="defs2074">
    <rect
       x="39.18819"
       y="56.393085"
       width="80.384132"
       height="38.173286"
       id="rect1146" />
    <rect
       x="145.99998"
       y="28.130173"
       width="74.144264"
       height="34.135727"
       id="rect1106" />
    <linearGradient
       id="linearGradient3355"
       osb:paint="solid">
      <stop
         style="stop-color:#0000ff;stop-opacity:1;"
         offset="0"
         id="stop3353" />
    </linearGradient>
    <inkscape:path-effect
       effect="bspline"
       id="path-effect909"
       is_visible="true"
       lpeversion="1"
       weight="33.333333"
       steps="2"
       helper_size="0"
       apply_no_weight="true"
       apply_with_weight="true"
       only_selected="false" />
    <inkscape:path-effect
       only_selected="false"
       apply_with_weight="true"
       apply_no_weight="true"
       helper_size="0"
       steps="2"
       weight="33.333333"
       lpeversion="1"
       is_visible="true"
       id="path-effect2849"
       effect="bspline" />
    <inkscape:path-effect
       only_selected="false"
       apply_with_weight="true"
       apply_no_weight="true"
       helper_size="0"
       steps="2"
       weight="33.333333"
       lpeversion="1"
       is_visible="true"
       id="path-effect2845"
       effect="bspline" />
    <rect
       id="rect2647"
       height="21.960417"
       width="23.547916"
       y="117.21042"
       x="25.4" />
    <rect
       x="25.4"
       y="117.21042"
       width="23.547916"
       height="21.960417"
       id="rect2835" />
    <rect
       id="rect2841"
       height="21.960417"
       width="23.547916"
       y="117.21042"
       x="25.4" />
    <rect
       id="rect1114"
       height="34.135727"
       width="74.144264"
       y="28.130173"
       x="145.99998" />
    <rect
       id="rect1154"
       height="38.173286"
       width="80.384132"
       y="56.393085"
       x="39.18819" />
    <rect
       x="39.18819"
       y="56.393085"
       width="80.384132"
       height="38.173286"
       id="rect1160" />
  </defs>
  <sodipodi:namedview
     inkscape:window-maximized="0"
     inkscape:window-y="23"
     inkscape:window-x="0"
     inkscape:window-height="1005"
     inkscape:window-width="1680"
     fit-margin-bottom="0"
     fit-margin-right="0"
     fit-margin-left="0"
     fit-margin-top="0"
     showgrid="false"
     inkscape:document-rotation="0"
     inkscape:current-layer="layer1"
     inkscape:document-units="mm"
     inkscape:cy="-31.343965"
     inkscape:cx="99.984644"
     inkscape:zoom="3.4055229"
     inkscape:pageshadow="2"
     inkscape:pageopacity="0.0"
     borderopacity="1.0"
     bordercolor="#666666"
     pagecolor="#ffffff"
     id="base" />
  <metadata
     id="metadata2077">
    <rdf:RDF>
      <cc:Work
         rdf:about="">
        <dc:format>image/svg+xml</dc:format>
        <dc:type
           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
        <dc:title />
      </cc:Work>
    </rdf:RDF>
  </metadata>
  <g
     transform="translate(-16.063987,-144.59981)"
     id="layer1"
     inkscape:groupmode="layer"
     inkscape:label="Layer 1">
    <g
       data-id="box0"
       id="g1132">
      <path
         d="M 19.0405 109.754 L 109.041 109.754 L 109.041 199.754 L 19.0405 199.754 Z"
         style="fill:none;stop-color:#000000;stroke:#ff5555;stroke-width:1.72125"
         id="rect2643" />
      <path
         d="M 19.0405 109.754 L 109.041 109.754 L 109.041 199.754 L 19.0405 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2704" />
      <g
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
         id="text2708"
         aria-label="0">
        <path
           id="path3657"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           d="M 69.6293 154.744 C 69.6293 157.645 69.1736 159.775 68.2619 161.134 C 67.3577 162.487 65.9504 163.165 64.0406 163.165 C 62.1017 163.165 60.6836 162.478 59.7866 161.104 C 58.8965 159.73 58.4516 157.615 58.4516 154.765 C 58.4516 151.891 58.904 149.773 59.8082 148.408 C 60.7124 147.031 62.1233 146.344 64.0406 146.344 C 65.9792 146.344 67.394 147.043 68.2838 148.438 C 69.1808 149.827 69.6293 151.93 69.6293 154.744 Z M 66.7751 159.67 C 67.0286 159.085 67.1984 158.398 67.2851 157.609 C 67.3793 156.814 67.4264 155.86 67.4264 154.744 C 67.4264 153.646 67.3793 152.689 67.2851 151.879 C 67.1984 151.069 67.025 150.379 66.7643 149.818 C 66.5114 149.26 66.164 148.84 65.7227 148.558 C 65.2886 148.276 64.7279 148.135 64.0406 148.135 C 63.3605 148.135 62.7962 148.276 62.3477 148.558 C 61.9064 148.84 61.5554 149.266 61.295 149.839 C 61.049 150.373 60.8792 151.072 60.785 151.933 C 60.6983 152.794 60.6548 153.736 60.6548 154.765 C 60.6548 155.896 60.6947 156.838 60.7739 157.597 C 60.8537 158.356 61.0238 159.037 61.2842 159.64 C 61.5227 160.201 61.8593 160.633 62.2934 160.93 C 62.7347 161.224 63.317 161.374 64.0406 161.374 C 64.7207 161.374 65.285 161.233 65.7335 160.951 C 66.182 160.669 66.5294 160.243 66.7751 159.67 Z" />
      </g>
    </g>
    <g
       data-id="box1"
       id="g1137">
      <path
         d="M 110.762 109.754 L 200.762 109.754 L 200.762 199.754 L 110.762 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2712" />
      <g
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
         id="text2716"
         aria-label="1">
        <path
           id="path3660"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           d="M 160.135 162.862 L 151.388 162.862 L 151.388 161.212 L 154.752 161.212 L 154.752 150.379 L 151.388 150.379 L 151.388 148.906 C 151.844 148.906 152.332 148.867 152.853 148.795 C 153.375 148.717 153.769 148.606 154.036 148.462 C 154.369 148.279 154.63 148.051 154.818 147.778 C 155.013 147.496 155.125 147.118 155.154 146.647 L 156.836 146.647 L 156.836 161.212 L 160.135 161.212 Z" />
      </g>
    </g>
    <g
       data-id="box2"
       id="g1142">
      <path
         d="M 202.483 109.754 L 292.483 109.754 L 292.483 199.754 L 202.483 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2720" />
      <g
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
         id="text2724"
         aria-label="2">
        <path
           id="path3663"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           d="M 252.953 163.003 L 242.014 163.003 L 242.014 160.735 C 242.774 160.081 243.532 159.433 244.293 158.782 C 245.06 158.128 245.771 157.48 246.43 156.838 C 247.819 155.491 248.77 154.426 249.286 153.637 C 249.799 152.842 250.055 151.984 250.055 151.063 C 250.055 150.226 249.776 149.569 249.22 149.101 C 248.669 148.624 247.9 148.384 246.907 148.384 C 246.25 148.384 245.537 148.498 244.77 148.732 C 244.003 148.963 243.253 149.317 242.524 149.794 L 242.414 149.794 L 242.414 147.517 C 242.929 147.265 243.613 147.031 244.466 146.821 C 245.328 146.611 246.158 146.509 246.961 146.509 C 248.62 146.509 249.918 146.908 250.858 147.712 C 251.799 148.507 252.269 149.587 252.269 150.955 C 252.269 151.57 252.19 152.146 252.031 152.683 C 251.877 153.211 251.65 153.712 251.347 154.189 C 251.065 154.639 250.732 155.08 250.348 155.515 C 249.972 155.95 249.513 156.43 248.971 156.958 C 248.197 157.717 247.396 158.455 246.572 159.172 C 245.746 159.88 244.977 160.54 244.259 161.146 L 252.953 161.146 Z" />
      </g>
    </g>
    <g
       data-id="box3"
       id="g1275">
      <path
         d="M 477.647 109.754 L 567.647 109.754 L 567.647 199.754 L 477.647 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95311"
         id="rect2744" />
      <g
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2835);fill:#000000;fill-opacity:1;stroke:none"
         id="text2833"
         aria-label="…">
        <path
           id="path3771"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           d="M 529.808 155.965 L 527.597 155.965 L 527.597 153.544 L 529.808 153.544 Z M 523.754 155.965 L 521.54 155.965 L 521.54 153.544 L 523.754 153.544 Z M 517.7 155.965 L 515.486 155.965 L 515.486 153.544 L 517.7 153.544 Z" />
      </g>
    </g>
    <g
       data-id="box4"
       id="g1270">
      <path
         d="M 385.926 109.754 L 475.926 109.754 L 475.926 199.754 L 385.926 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2736" />
      <g
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2841);fill:#000000;fill-opacity:1;stroke:none"
         id="text2839"
         aria-label="…">
        <path
           id="path3667"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           d="M 438.086 155.965 L 435.875 155.965 L 435.875 153.544 L 438.086 153.544 Z M 432.032 155.965 L 429.818 155.965 L 429.818 153.544 L 432.032 153.544 Z M 425.978 155.965 L 423.764 155.965 L 423.764 153.544 L 425.978 153.544 Z" />
      </g>
    </g>
    <g
       data-id="box5"
       id="g1285">
      <path
         d="M 661.089 109.754 L 751.089 109.754 L 751.089 199.754 L 661.089 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2760" />
      <g
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
         id="text2772"
         aria-label="…">
        <path
           id="path3683"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           d="M 713.252 155.965 L 711.038 155.965 L 711.038 153.544 L 713.252 153.544 Z M 707.195 155.965 L 704.981 155.965 L 704.981 153.544 L 707.195 153.544 Z M 701.141 155.965 L 698.927 155.965 L 698.927 153.544 L 701.141 153.544 Z" />
      </g>
    </g>
    <g
       data-id="box6"
       id="g1280">
      <path
         d="M 569.368 109.754 L 659.368 109.754 L 659.368 199.754 L 569.368 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2752" />
      <g
         aria-label="…"
         id="g1092"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none">
        <path
           d="M 621.53 155.965 L 619.319 155.965 L 619.319 153.544 L 621.53 153.544 Z M 615.476 155.965 L 613.262 155.965 L 613.262 153.544 L 615.476 153.544 Z M 609.419 155.965 L 607.205 155.965 L 607.205 153.544 L 609.419 153.544 Z"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           id="path1090" />
      </g>
    </g>
    <g
       data-id="box7"
       id="g1265">
      <path
         d="M 294.204 109.754 L 384.204 109.754 L 384.204 199.754 L 294.204 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2728" />
      <g
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.33333px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect1146)"
         id="text1144"
         aria-label="3">
        <path
           id="path1176"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.33333px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           d="M 343.85 155.089 C 344.24 155.44 344.561 155.878 344.813 156.409 C 345.065 156.937 345.191 157.621 345.191 158.458 C 345.191 159.289 345.041 160.051 344.741 160.741 C 344.438 161.434 344.015 162.037 343.469 162.55 C 342.86 163.117 342.14 163.54 341.309 163.819 C 340.487 164.086 339.584 164.221 338.6 164.221 C 337.592 164.221 336.599 164.098 335.621 163.855 C 334.646 163.618 333.842 163.357 333.218 163.072 L 333.218 160.522 L 333.401 160.522 C 334.091 160.978 334.904 161.356 335.84 161.656 C 336.776 161.959 337.679 162.109 338.552 162.109 C 339.065 162.109 339.608 162.025 340.187 161.854 C 340.766 161.683 341.234 161.431 341.591 161.095 C 341.966 160.738 342.242 160.342 342.422 159.913 C 342.608 159.481 342.701 158.935 342.701 158.275 C 342.701 157.624 342.596 157.087 342.383 156.664 C 342.182 156.232 341.897 155.896 341.531 155.653 C 341.162 155.398 340.721 155.227 340.199 155.14 C 339.677 155.041 339.116 154.993 338.513 154.993 L 337.415 154.993 L 337.415 152.965 L 338.27 152.965 C 339.506 152.965 340.493 152.71 341.225 152.197 C 341.966 151.675 342.335 150.919 342.335 149.926 C 342.335 149.488 342.242 149.104 342.053 148.78 C 341.867 148.444 341.606 148.174 341.273 147.961 C 340.922 147.751 340.55 147.604 340.151 147.523 C 339.752 147.439 339.299 147.4 338.795 147.4 C 338.021 147.4 337.199 147.538 336.329 147.814 C 335.459 148.09 334.637 148.483 333.863 148.987 L 333.74 148.987 L 333.74 146.434 C 334.319 146.149 335.087 145.891 336.05 145.654 C 337.016 145.411 337.952 145.288 338.855 145.288 C 339.743 145.288 340.526 145.369 341.201 145.531 C 341.876 145.696 342.485 145.954 343.031 146.314 C 343.616 146.704 344.06 147.175 344.363 147.73 C 344.663 148.282 344.813 148.93 344.813 149.671 C 344.813 150.679 344.456 151.561 343.739 152.32 C 343.031 153.067 342.194 153.541 341.225 153.736 L 341.225 153.907 C 341.615 153.97 342.062 154.108 342.566 154.321 C 343.073 154.525 343.499 154.78 343.85 155.089 Z" />
      </g>
    </g>
    <g
       data-id="box8"
       id="g1292">
      <path
         d="M 752.811 109.754 L 842.811 109.754 L 842.811 199.754 L 752.811 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2768" />
      <g
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.33333px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect1154)"
         id="text1152"
         aria-label="k-1">
        <path
           id="path1169"
           d="M 791.567 163.843 L 788.54 163.843 L 783.071 157.873 L 781.583 159.289 L 781.583 163.843 L 779.288 163.843 L 779.288 144.847 L 781.583 144.847 L 781.583 157.03 L 788.21 150.208 L 791.105 150.208 L 784.769 156.505 Z" />
        <path
           id="path1171"
           d="M 801.212 156.994 L 793.595 156.994 L 793.595 154.786 L 801.212 154.786 Z" />
        <path
           id="path1173"
           d="M 816.335 163.843 L 806.498 163.843 L 806.498 161.986 L 810.281 161.986 L 810.281 149.803 L 806.498 149.803 L 806.498 148.144 C 807.011 148.144 807.56 148.105 808.145 148.021 C 808.73 147.934 809.174 147.808 809.474 147.643 C 809.849 147.439 810.143 147.184 810.353 146.875 C 810.575 146.557 810.701 146.134 810.734 145.606 L 812.624 145.606 L 812.624 161.986 L 816.335 161.986 Z" />
      </g>
    </g>
    <g
       data-id="box9"
       id="g1301">
      <path
         d="M 844.532 109.754 L 934.532 109.754 L 934.532 199.754 L 844.532 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2776" />
      <g
         style="fill:#cccccc;stroke:#000000;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:0.0"
         id="g2852">
        <path
           id="path2843"
           d="M 934.532 109.753 L 842.81 199.753"
           style="fill:#cccccc;stroke:#000000;stroke-dasharray:none;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-width:0.0">
          <path
             style="fill:#cccccc;stroke:#000000;stroke-dasharray:none;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-width:0.0"
             d="M 842.81 109.753 L 934.532 199.753"
             id="path2847" />
        </path>
      </g>
      <path
         id="path907"
         d="M 844.532 109.754 C 874.532 139.755 904.532 169.755 934.532 199.754"
         style="fill:#cccccc;stroke:#000000;stroke-dasharray:none;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-width:0.0" />
      <g
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.33333px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect1160)"
         id="text1158"
         aria-label="k">
        <path
           id="path1166"
           d="M 895.28 163.843 L 892.253 163.843 L 886.784 157.873 L 885.296 159.289 L 885.296 163.843 L 883.001 163.843 L 883.001 144.847 L 885.296 144.847 L 885.296 157.03 L 891.923 150.208 L 894.818 150.208 L 888.482 156.505 Z" />
      </g>
    </g>
  </g>
</svg>

Note: It maintains a table of size K and delivers a randomly selected number from that table when requested, replacing it with a number generated by the base engine

---

## `shuffle_order_engine`

```cpp
///hide
#include <cstddef>

///unhide
template<class Engine,
         std::size_t K> 
class shuffle_order_engine;
```

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
   xmlns:osb="http://www.openswatchbook.org/uri/2009/osb"
   xmlns:dc="http://purl.org/dc/elements/1.1/"
   xmlns:cc="http://creativecommons.org/ns#"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   class="animated"
   width="552.35004pt"
   height="57.573677pt"
   viewBox="0 0 920.58351 95.956136"
   version="1.1"
   id="svg2080"
   inkscape:version="1.0 (4035a4f, 2020-05-01)"
   sodipodi:docname="shuffle_post.svg">
  <defs
     id="defs2074">
    <rect
       id="rect1146"
       height="38.173286"
       width="80.384132"
       y="56.393085"
       x="39.18819" />
    <rect
       id="rect1106"
       height="34.135727"
       width="74.144264"
       y="28.130173"
       x="145.99998" />
    <linearGradient
       osb:paint="solid"
       id="linearGradient3355">
      <stop
         id="stop3353"
         offset="0"
         style="stop-color:#0000ff;stop-opacity:1;" />
    </linearGradient>
    <inkscape:path-effect
       only_selected="false"
       apply_with_weight="true"
       apply_no_weight="true"
       helper_size="0"
       steps="2"
       weight="33.333333"
       lpeversion="1"
       is_visible="true"
       id="path-effect909"
       effect="bspline" />
    <inkscape:path-effect
       effect="bspline"
       id="path-effect2849"
       is_visible="true"
       lpeversion="1"
       weight="33.333333"
       steps="2"
       helper_size="0"
       apply_no_weight="true"
       apply_with_weight="true"
       only_selected="false" />
    <inkscape:path-effect
       effect="bspline"
       id="path-effect2845"
       is_visible="true"
       lpeversion="1"
       weight="33.333333"
       steps="2"
       helper_size="0"
       apply_no_weight="true"
       apply_with_weight="true"
       only_selected="false" />
    <rect
       x="25.4"
       y="117.21042"
       width="23.547916"
       height="21.960417"
       id="rect2647" />
    <rect
       id="rect2835"
       height="21.960417"
       width="23.547916"
       y="117.21042"
       x="25.4" />
    <rect
       x="25.4"
       y="117.21042"
       width="23.547916"
       height="21.960417"
       id="rect2841" />
    <rect
       x="145.99998"
       y="28.130173"
       width="74.144264"
       height="34.135727"
       id="rect1114" />
    <rect
       x="39.18819"
       y="56.393085"
       width="80.384132"
       height="38.173286"
       id="rect1154" />
    <rect
       id="rect1160"
       height="38.173286"
       width="80.384132"
       y="56.393085"
       x="39.18819" />
  </defs>
  <sodipodi:namedview
     units="pt"
     id="base"
     pagecolor="#ffffff"
     bordercolor="#666666"
     borderopacity="1.0"
     inkscape:pageopacity="0.0"
     inkscape:pageshadow="2"
     inkscape:zoom="3.4055229"
     inkscape:cx="123.03542"
     inkscape:cy="43.705784"
     inkscape:document-units="mm"
     inkscape:current-layer="layer1"
     inkscape:document-rotation="0"
     showgrid="false"
     fit-margin-top="0"
     fit-margin-left="0"
     fit-margin-right="0"
     fit-margin-bottom="0"
     inkscape:window-width="1680"
     inkscape:window-height="1005"
     inkscape:window-x="0"
     inkscape:window-y="23"
     inkscape:window-maximized="0" />
  <metadata
     id="metadata2077">
    <rdf:RDF>
      <cc:Work
         rdf:about="">
        <dc:format>image/svg+xml</dc:format>
        <dc:type
           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
        <dc:title />
      </cc:Work>
    </rdf:RDF>
  </metadata>
  <g
     inkscape:label="Layer 1"
     inkscape:groupmode="layer"
     id="layer1"
     transform="translate(-16.06401,-106.77781)">
    <g
       data-id="box0"
       id="g1132">
      <path
         d="M 752.81 109.754 L 842.81 109.754 L 842.81 199.754 L 752.81 199.754 Z"
         style="fill:none;stop-color:#000000;stroke:#ff5555;stroke-width:1.72125"
         id="rect2643" />
      <path
         d="M 752.81 109.754 L 842.81 109.754 L 842.81 199.754 L 752.81 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2704" />
      <g
         aria-label="0"
         id="text2708"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none">
        <path
           d="M 803.399 154.745 C 803.399 157.646 802.943 159.776 802.031 161.135 C 801.128 162.488 799.721 163.166 797.81 163.166 C 795.872 163.166 794.453 162.479 793.556 161.105 C 792.668 159.731 792.221 157.616 792.221 154.766 C 792.221 151.892 792.674 149.774 793.577 148.409 C 794.483 147.032 795.893 146.345 797.81 146.345 C 799.748 146.345 801.164 147.044 802.055 148.439 C 802.952 149.828 803.399 151.931 803.399 154.745 Z M 800.546 159.671 C 800.798 159.086 800.969 158.399 801.056 157.61 C 801.149 156.815 801.197 155.861 801.197 154.745 C 801.197 153.647 801.149 152.69 801.056 151.88 C 800.969 151.07 800.795 150.38 800.534 149.819 C 800.282 149.261 799.934 148.841 799.493 148.559 C 799.058 148.277 798.497 148.136 797.81 148.136 C 797.132 148.136 796.565 148.277 796.118 148.559 C 795.677 148.841 795.326 149.267 795.065 149.84 C 794.819 150.374 794.648 151.073 794.555 151.934 C 794.468 152.795 794.426 153.737 794.426 154.766 C 794.426 155.897 794.465 156.839 794.543 157.598 C 794.624 158.357 794.795 159.038 795.053 159.641 C 795.293 160.202 795.629 160.634 796.064 160.931 C 796.505 161.225 797.087 161.375 797.81 161.375 C 798.491 161.375 799.055 161.234 799.505 160.952 C 799.952 160.67 800.3 160.244 800.546 159.671 Z"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           id="path3657" />
      </g>
    </g>
    <g
       data-id="box1"
       id="g1137">
      <path
         d="M 477.647 109.754 C 507.647 109.754 537.647 109.754 567.647 109.754 C 567.647 139.754 567.647 169.754 567.647 199.754 C 537.647 199.754 507.647 199.754 477.647 199.754 C 477.647 169.754 477.647 139.754 477.647 109.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2712" />
      <g
         aria-label="1"
         id="text2716"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none">
        <path
           d="M 527.021 162.863 C 524.105 162.863 521.189 162.863 518.273 162.863 C 517.473 160.427 520.055 161.374 521.53 161.213 C 521.785 157.821 521.566 153.954 521.639 150.38 C 520.267 150.138 517.55 151.243 518.273 148.907 C 520.736 150.15 523.419 143.971 523.721 148.005 C 523.721 152.408 523.721 156.81 523.721 161.213 C 525.187 161.389 527.813 160.407 527.021 162.841 Z"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           id="path3660" />
      </g>
    </g>
    <g
       data-id="box2"
       id="g1142">
      <path
         d="M 202.483 109.755 L 292.483 109.755 L 292.483 199.755 L 202.483 199.755 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2720" />
      <g
         aria-label="2"
         id="text2724"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none">
        <path
           d="M 252.953 163.004 L 242.014 163.004 L 242.014 160.736 C 242.774 160.082 243.532 159.434 244.293 158.783 C 245.06 158.129 245.771 157.481 246.43 156.839 C 247.819 155.492 248.77 154.427 249.286 153.638 C 249.799 152.843 250.055 151.985 250.055 151.064 C 250.055 150.227 249.776 149.57 249.22 149.102 C 248.669 148.625 247.9 148.385 246.907 148.385 C 246.25 148.385 245.537 148.499 244.77 148.733 C 244.003 148.964 243.253 149.318 242.524 149.795 L 242.414 149.795 L 242.414 147.518 C 242.929 147.266 243.613 147.032 244.466 146.822 C 245.328 146.612 246.158 146.51 246.961 146.51 C 248.62 146.51 249.918 146.909 250.858 147.713 C 251.799 148.508 252.269 149.588 252.269 150.956 C 252.269 151.571 252.19 152.147 252.031 152.684 C 251.877 153.212 251.65 153.713 251.347 154.19 C 251.065 154.64 250.732 155.081 250.348 155.516 C 249.972 155.951 249.513 156.431 248.971 156.959 C 248.197 157.718 247.396 158.456 246.572 159.173 C 245.746 159.881 244.977 160.541 244.259 161.147 L 252.953 161.147 Z"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           id="path3663" />
      </g>
    </g>
    <g
       data-id="box3"
       id="g1275">
      <path
         id="rect2744"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95311"
         d="M 110.762 109.754 L 200.762 109.754 L 200.762 199.754 L 110.762 199.754 Z" />
      <g
         aria-label="…"
         id="text2833"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2835);fill:#000000;fill-opacity:1;stroke:none">
        <path
           d="M 162.923 155.966 L 160.712 155.966 L 160.712 153.545 L 162.923 153.545 Z M 156.869 155.966 L 154.655 155.966 L 154.655 153.545 L 156.869 153.545 Z M 150.815 155.966 L 148.601 155.966 L 148.601 153.545 L 150.815 153.545 Z"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           id="path3771" />
      </g>
    </g>
    <g
       data-id="box4"
       id="g1270">
      <path
         d="M 385.926 109.755 L 475.926 109.755 L 475.926 199.755 L 385.926 199.755 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2736" />
      <g
         aria-label="…"
         id="text2839"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2841);fill:#000000;fill-opacity:1;stroke:none">
        <path
           d="M 438.086 155.966 L 435.875 155.966 L 435.875 153.545 L 438.086 153.545 Z M 432.032 155.966 L 429.818 155.966 L 429.818 153.545 L 432.032 153.545 Z M 425.978 155.966 L 423.764 155.966 L 423.764 153.545 L 425.978 153.545 Z"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           id="path3667" />
      </g>
    </g>
    <g
       data-id="box5"
       id="g1285">
      <path
         d="M 661.089 109.755 L 751.089 109.755 L 751.089 199.755 L 661.089 199.755 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2760" />
      <g
         aria-label="…"
         id="text2772"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none">
        <path
           d="M 713.252 155.966 L 711.038 155.966 L 711.038 153.545 L 713.252 153.545 Z M 707.195 155.966 L 704.981 155.966 L 704.981 153.545 L 707.195 153.545 Z M 701.141 155.966 L 698.927 155.966 L 698.927 153.545 L 701.141 153.545 Z"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           id="path3683" />
      </g>
    </g>
    <g
       data-id="box6"
       id="g1280">
      <path
         d="M 569.368 109.755 L 659.368 109.755 L 659.368 199.755 L 569.368 199.755 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2752" />
      <g
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect2647);fill:#000000;fill-opacity:1;stroke:none"
         id="g1092"
         aria-label="…">
        <path
           id="path1090"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:9.87778px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           d="M 621.53 155.966 L 619.319 155.966 L 619.319 153.545 L 621.53 153.545 Z M 615.476 155.966 L 613.262 155.966 L 613.262 153.545 L 615.476 153.545 Z M 609.419 155.966 L 607.205 155.966 L 607.205 153.545 L 609.419 153.545 Z" />
      </g>
    </g>
    <g
       data-id="box7"
       id="g1265">
      <path
         d="M 843.671 109.754 L 933.671 109.754 L 933.671 199.754 L 843.671 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2728" />
      <g
         aria-label="3"
         id="text1144"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.33333px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect1146)">
        <path
           d="M 893.318 155.09 C 893.708 155.441 894.029 155.879 894.281 156.41 C 894.533 156.938 894.659 157.622 894.659 158.459 C 894.659 159.29 894.509 160.052 894.209 160.742 C 893.906 161.435 893.483 162.038 892.937 162.551 C 892.328 163.118 891.608 163.541 890.777 163.82 C 889.955 164.087 889.052 164.222 888.068 164.222 C 887.06 164.222 886.067 164.099 885.089 163.856 C 884.114 163.619 883.31 163.358 882.686 163.073 L 882.686 160.523 L 882.869 160.523 C 883.559 160.979 884.372 161.357 885.308 161.657 C 886.244 161.96 887.147 162.11 888.02 162.11 C 888.533 162.11 889.076 162.026 889.655 161.855 C 890.234 161.684 890.702 161.432 891.059 161.096 C 891.434 160.739 891.71 160.343 891.89 159.914 C 892.076 159.482 892.169 158.936 892.169 158.276 C 892.169 157.625 892.064 157.088 891.851 156.665 C 891.65 156.233 891.365 155.897 890.999 155.654 C 890.63 155.399 890.189 155.228 889.667 155.141 C 889.145 155.042 888.584 154.994 887.981 154.994 L 886.883 154.994 L 886.883 152.966 L 887.738 152.966 C 888.974 152.966 889.961 152.711 890.693 152.198 C 891.434 151.676 891.803 150.92 891.803 149.927 C 891.803 149.489 891.71 149.105 891.521 148.781 C 891.335 148.445 891.074 148.175 890.741 147.962 C 890.39 147.752 890.018 147.605 889.619 147.524 C 889.22 147.44 888.767 147.401 888.263 147.401 C 887.489 147.401 886.667 147.539 885.797 147.815 C 884.927 148.091 884.105 148.484 883.331 148.988 L 883.208 148.988 L 883.208 146.435 C 883.787 146.15 884.555 145.892 885.518 145.655 C 886.484 145.412 887.42 145.289 888.323 145.289 C 889.211 145.289 889.994 145.37 890.669 145.532 C 891.344 145.697 891.953 145.955 892.499 146.315 C 893.084 146.705 893.528 147.176 893.831 147.731 C 894.131 148.283 894.281 148.931 894.281 149.672 C 894.281 150.68 893.924 151.562 893.207 152.321 C 892.499 153.068 891.662 153.542 890.693 153.737 L 890.693 153.908 C 891.083 153.971 891.53 154.109 892.034 154.322 C 892.541 154.526 892.967 154.781 893.318 155.09 Z"
           style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.33333px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal"
           id="path1176" />
      </g>
    </g>
    <g
       data-id="box8"
       id="g1292">
      <path
         d="M 19.0406 109.754 L 109.041 109.754 L 109.041 199.754 L 19.0406 199.754 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2768" />
      <g
         aria-label="k-1"
         id="text1152"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.33333px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect1154)">
        <path
           d="M 57.797 163.844 L 54.77 163.844 L 49.301 157.874 L 47.813 159.29 L 47.813 163.844 L 45.518 163.844 L 45.518 144.848 L 47.813 144.848 L 47.813 157.031 L 54.44 150.209 L 57.335 150.209 L 50.999 156.506 Z"
           id="path1169" />
        <path
           d="M 67.442 156.995 L 59.825 156.995 L 59.825 154.787 L 67.442 154.787 Z"
           id="path1171" />
        <path
           d="M 82.565 163.844 L 72.728 163.844 L 72.728 161.987 L 76.511 161.987 L 76.511 149.804 L 72.728 149.804 L 72.728 148.145 C 73.241 148.145 73.79 148.106 74.375 148.022 C 74.96 147.935 75.404 147.809 75.704 147.644 C 76.079 147.44 76.373 147.185 76.583 146.876 C 76.805 146.558 76.931 146.135 76.964 145.607 L 78.854 145.607 L 78.854 161.987 L 82.565 161.987 Z"
           id="path1173" />
      </g>
    </g>
    <g
       data-id="box9"
       id="g1301">
      <path
         d="M 295.064 109.757 L 385.064 109.757 L 385.064 199.757 L 295.064 199.757 Z"
         style="fill:#bee4fd;fill-opacity:1;stop-color:#000000;stroke:#3e4837;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:5.95314"
         id="rect2776" />
      <g
         id="g2852"
         style="fill:#cccccc;stroke:#000000;stroke-dasharray:none;stroke-miterlimit:4;stroke-opacity:1;stroke-width:0.0">
        <path
           style="fill:#cccccc;stroke:#000000;stroke-dasharray:none;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-width:0.0"
           d="M 385.064 109.754 L 293.342 199.754"
           id="path2843">
          <path
             id="path2847"
             d="M 293.342 109.754 L 385.064 199.754"
             style="fill:#cccccc;stroke:#000000;stroke-dasharray:none;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-width:0.0" />
        </path>
      </g>
      <path
         style="fill:#cccccc;stroke:#000000;stroke-dasharray:none;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-opacity:1;stroke-width:0.0"
         d="M 295.064 109.757 C 325.064 139.757 355.064 169.757 385.064 199.757"
         id="path907" />
      <g
         aria-label="k"
         id="text1158"
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:8.33333px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect1160)">
        <path
           d="M 345.812 163.844 L 342.785 163.844 L 337.316 157.874 L 335.828 159.29 L 335.828 163.844 L 333.533 163.844 L 333.533 144.848 L 335.828 144.848 L 335.828 157.031 L 342.455 150.209 L 345.35 150.209 L 339.014 156.506 Z"
           id="path1166" />
      </g>
    </g>
  </g>
</svg>

---

## predefined

## `shuffle_order_engine`

```cpp
///hide
#include <cstdint>
#include <cstddef>

template <class UIntType, 
          UIntType a, UIntType c, UIntType m>
class linear_congruential_engine;

using minstd_rand0 =
    linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>;

///unhide
template<class Engine,
         std::size_t K> 
class shuffle_order_engine;

using knuth_b =
  shuffle_order_engine<minstd_rand0, 256>;
```

---

## `independent_bits_engine`

```cpp
///hide
#include <cstddef>

///unhide
template<class Engine,
         std::size_t W,
         class UIntType> 
class independent_bits_engine;
```

Note: produces random numbers with different number of bits than that of the wrapped engine

---

## what to choose

| engine | quality | speed | state size |
|--------|---------|-------|------------|
|`linear_congruential_engine`|medium|medium|1 word|
|`mersenne_twister_engine`|good|fast|624 words|
|`subtract_with_carry_engine`|medium|fast|25 words|
|`discard_block_engine`|good|slow|base + 1 word|
|`shuffle_order_engine`|good|fast|base + 100 words|

Note:
- quality: What is the cycle length? Does the engine pass all relevant statistical tests?
- speed: How many and what kind of operations have to be performed to produce one random number, on average?

---

## distributions

Note: It makes no sense to ask for a random number without some context. 
A distribution’s role is to return random numbers (variates) whose likelihoods correspond to
a specific shape. E.g., a normal distribution produces variates according to a "bell-shaped
curve."

---

## what can it do

```cpp [1-2,17|3|5-7|9-16]
///hide
#include <random>
#include <iostream>
#include <cassert>
#include <sstream>

///unhide
template<typename Distribution, typename Engine>
void distribute(Engine& e) {
  Distribution d;

std::cout << "d's range is [" 
            << d.min() << "," 
            << d.max() << "]\n";

std::stringstream sst;
  sst << e << '\n' << d << '\n';
  const auto n1 = d(e);
  d(e);

sst >> e >> d;
  const auto n2 = d(e);
  assert(n1 == n2);
}
///hide

int main() {
  std::default_random_engine e;
  distribute<std::uniform_int_distribution<>>(e);
}
```

Note: 
1. default constructible
2. generates values between `min` and `max`
3. can be serialized/deserialized to an `iostream`
4. can be called directly
5. can be reseeded
6. results can be discarded

---

## distribution parameters

```cpp [1-2,13|3|5-6|6,8-9|6,11-12]
///hide
#include <cassert>
#include <random>

///unhide
template<typename Distribution, typename Engine, typename... Params>
void distribute(Engine& e, Params... params) {
  Distribution d1{params...};

typename Distribution::param_type p{params...};
  Distribution d2{p};

d1.param(p);
  assert(d1.param() == d2.param());

Distribution d3;
  assert(d3(e, p) == d2(e));
}

///hide

int main() {
  std::default_random_engine e;
  distribute<std::uniform_int_distribution<>>(e, 1, 6);
}
```

---

## Library distributions

no default this time

---

## uniform distributions

![Cardano](12_random/Cardano.jpg)

Note: Gerolamo Cardano, one of the fathers of the probability theory.

---

### integral uniform distribution

```cpp
template<class IntType = int>
class uniform_int_distribution;
```

`$$ P(i|a,b) = \frac{1}{b-a+1} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`a`|`IntType`|`0`|
|`b`|`IntType`|`numeric_limits<IntType>::max()`|

</parameters>

![uniform_int_distribution](12_random/uniform_int_distribution.svg)

</diagram>

</div>

Note: Produces random integer values `i`, uniformly distributed on the closed interval `[a, b]`

---

### floating point uniform distribution

```cpp
template<class RealType = double>
class uniform_real_distribution;
```

`$$ P(i|a,b) = \frac{1}{b-a} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`a`|`RealType`|`0.0`|
|`b`|`RealType`|`1.0`|

</parameters>

![uniform_real_distribution](12_random/uniform_real_distribution.svg)

</diagram>

</div>

Note: Produces random floating-point values `i`, uniformly distributed on the closed interval `[a, b]`

---

## Bernoulli distributions

![Bernoulli](12_random/Bernoulli.jpg)

Note: named after Swiss mathematician Jacob Bernoulli.

---

### Bernoulli distribution

```cpp
class bernoulli_distribution;
```

`$$ P(b|p) = \begin{cases}
   p & \text{if }b == true, \\
   1-p & \text {if } b == false.
 \end{cases} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`p`|`double`|`0.5`|

</parameters>

![bernoulli_distribution](12_random/bernoulli_distribution.svg)

</diagram>

</div>

Note: Produces random boolean values, according to the discrete probability function. It can be thought of as a model for the set of possible outcomes of any single experiment that asks a yes–no question (coin toss).

---

### Binomial distribution

```cpp
template<class IntType = int>
class binomial_distribution;
```

`$$ P(i|t,p) = \binom{t}{i}p^i(1-p)^{t-i} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`t`|`IntType`|`1`|
|`p`|`double`|`0.5`|

</parameters>

![binomial_distribution](12_random/binomial_distribution.svg)

</diagram>

</div>

Note: The value obtained is the number of successes in a sequence of `t` yes/no experiments, each of which succeeds with probability `p`. Notice that Bernoulli distribution is a special case of the binomial distribution, where `t = 1`.

---

### Negative Binomial distribution

```cpp
template<class IntType = int>
class negative_binomial_distribution;
```

`$$ P(i|k,p) = \binom{k+i-1}{i}p^k(1-p)^i $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`k`|`IntType`|`1`|
|`p`|`double`|`0.5`|

</parameters>

![negative_binomial_distribution](12_random/negative_binomial_distribution.svg)

</diagram>

</div>

Note: The value represents the number of failures in a series of independent yes/no trials (each succeeds with probability `p`), before exactly `k` successes occur.

---

### Geometric distribution

```cpp
template<class IntType = int>
class geometric_distribution;
```

`$$ P(i|p) = p\cdot(1-p)^i $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`p`|`double`|`0.5`|

</parameters>

![geometric_distribution](12_random/geometric_distribution.svg)

</diagram>

</div>

Note: The value represents the number of yes/no trials (each succeeding with probability `p`) which are necessary to obtain a single success. It is exactly equivalent to `std::negative_binomial_distribution<>(1, p)`;

---

## Poisson distributions

![Poisson](12_random/Poisson.jpg)

Note: named after French mathematician Siméon Denis Poisson

---

### Poisson distribution

```cpp
template<class IntType = int>
class poisson_distribution;
```

`$$ P(i|\mu) = \frac{e^{-\mu} \mu^i}{i!} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`mean`|`double`|`1.0`|

</parameters>

![poisson_distribution](12_random/poisson_distribution.svg)

</diagram>

</div>

Note: The value obtained is the probability of exactly `i` occurrences of a random event if the expected, mean number of its occurrence under the same conditions (on the same time/space interval) is `μ`.

The Poisson distribution may be useful to model events such as
- The number of meteorites greater than 1 meter diameter that strike Earth in a year
- The number of patients arriving in an emergency room between 10 and 11 pm
- The number of laser photons hitting a detector in a particular time interval

---

### Exponential distribution

```cpp
template<class RealType = double>
class exponential_distribution;
```

`$$ P(x|\lambda) = \lambda e^{-\lambda x} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`lambda`|`RealType`|`1.0`|

</parameters>

![exponential_distribution](12_random/exponential_distribution.svg)

</diagram>

</div>

Note: The value obtained is the time/distance until the next random event if random events occur at constant rate λ per unit of time/distance. For example, the time it takes before the next telephone call in a call center.

---

### Gamma distribution

```cpp
template<class RealType = double>
class gamma_distribution;
```

`$$ P(x|\alpha,\beta) = \frac{e^{-x/\beta}}{\beta^a\cdot\Gamma(\alpha)}\cdot x^{\alpha-1} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`alpha`|`RealType`|`1.0`|
|`beta`|`RealType`|`1.0`|

</parameters>

![gamma_distribution](12_random/gamma_distribution.svg)

</diagram>

</div>

Note: The value obtained is the sum of `α` independent exponentially distributed random variables, each of which has a mean of `β`. This is a generalization of the exponential distribution. The gamma distribution is used to model the fading of signal power in wireless communication.

---

### Weibull distribution

```cpp
template<class RealType = double>
class weibull_distribution;
```

`$$ P(x|a,b) = \frac{a}{b}(\frac{x}{b})^{a-1}e^{-(x/b)^a} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`a`|`RealType`|`1.0`|
|`b`|`RealType`|`1.0`|

</parameters>

![weibull_distribution](12_random/weibull_distribution.svg)

</diagram>

</div>

Note: The Weibull distribution is often used in the field of failure analysis; in particular it can mimic distributions where the failure rate varies over time.

---

### Extreme value distribution

```cpp
template<class RealType = double>
class extreme_value_distribution;
```

`$$ P(x|a,b) = \frac{1}{b}e^{\frac{a-x}{b}-e^{(a-x)/b}} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`a`|`RealType`|`0.0`|
|`b`|`RealType`|`1.0`|

</parameters>

![extreme_value_distribution](12_random/extreme_value_distribution.svg)

</diagram>

</div>

Note: AKA Gumbel distribution. Used to model the distribution of the maximum (or the minimum) of a number of samples of various distributions. For example, the distribution of the maximum level of a river in a particular year if there was a list of maximum values for the past ten years.

---

## normal distributions

![Gauss](12_random/Gauss.jpg)

Note: AKA Gaussian distributions after the German mathematician Johann Carl Friedrich Gauss.

---

### Normal distribution

```cpp
template<class RealType = double>
class normal_distribution;
```

`$$ P(x|\mu,\sigma) = \frac{1}{\sigma\sqrt{2\pi}}e^{-\frac{1}{2}(\frac{x-\mu}{\sigma})^2} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`mean`|`RealType`|`0.0`|
|`stddev`|`RealType`|`1.0`|

</parameters>

![normal_distribution](12_random/normal_distribution.svg)

</diagram>

</div>

Note: probably the most well known statistical distribution. For example, total distance covered in a random walk.

---

### Log-normal distribution

```cpp
template<class RealType = double>
class lognormal_distribution;
```

`$$ P(x|m,s) = \frac{1}{sx\sqrt{2\pi}}e^{-\frac{(\ln{x}-m)^2}{2s^2}} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`m`|`RealType`|`0.0`|
|`s`|`RealType`|`1.0`|

</parameters>

![lognormal_distribution](12_random/lognormal_distribution.svg)

</diagram>

</div>

Note: important in the description of natural phenomena. e.g. The length of comments posted in internet discussion forums.

---

### Chi-square distribution

```cpp
template<class RealType = double>
class chi_squared_distribution;
```

`$$ P(x|n) = \frac{x^{(n/2)-1}e^{-x/2}}{\Gamma(n/2)2^{n/2}} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`n`|`RealType`|`1.0`|

</parameters>

![chi_squared_distribution](12_random/chi_squared_distribution.svg)

</diagram>

</div>

Note: Value is the sum of the squares of `n` independent standard normal random variables. It is one of the most widely used distributions in statistical tests, and is often encountered in magnetic resonance imaging (MRI).

---

### Cauchy distribution

```cpp
template<class RealType = double>
class cauchy_distribution;
```

`$$ P(x|a,b) = (b\pi[1+\frac{x-a}{b}^2])^{-1} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`a`|`RealType`|`0.0`|
|`b`|`RealType`|`1.0`|

</parameters>

![cauchy_distribution](12_random/cauchy_distribution.svg)

</diagram>

</div>

Note: It the distribution of the ratio of two independent normally distributed random variables with mean zero.

---

### F-distribution

```cpp
template<class RealType = double>
class fisher_f_distribution;
```

`$$ P(x|m,n) = \frac{\Gamma\big((m+n)/2\big)
     \cdot \left(\frac{m}{n}\right)^{m/2}
     \cdot x^{(m/2)-1}}{\Gamma(m/2) \; \Gamma(n/2) \left(1 + \frac{m x}{n}\right)^{(m + n)/2}} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`m`|`RealType`|`1.0`|
|`n`|`RealType`|`1.0`|

</parameters>

![fisher_f_distribution](12_random/fisher_f_distribution.svg)

</diagram>

</div>

Note: It is most often used when comparing statistical models that have been fitted to a data set, in order to identify the model that best fits the population from which the data were sampled.

---

### Student's t-distribution

```cpp
template<class RealType = double>
class student_t_distribution;
```

`$$ P(x|n) = \frac{\Gamma\big((n+1)/2\big)}{\Gamma(n/2)\sqrt{n \pi}\left(1 + \frac{x^2}{n} \right)^{(n+1)/2}} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`n`|`RealType`|`1.0`|

</parameters>

![student_t_distribution](12_random/student_t_distribution.svg)

</diagram>

</div>

Note: It is used when estimating the mean of a normally distributed population in situations where the sample size is small and the population standard deviation is unknown.

---

## Sampling distributions

![Shannon](12_random/Shannon.jpeg)

Note: Sampling distributions are useful when you need to define a distribution based on a set of sample values, typically samples from the real world. The meaning of entropy in the context of data was developed by an American mathematician named Claude Shannon.

---

### Discrete distribution

```cpp
template<class IntType = int>
class discrete_distribution;
```

`$$ P(i \,|\, p_0, \dotsc, p_{n-1}) = p_i $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`probabilities`|`std::vector<double>`|`{1.0}`|

</parameters>

![discrete_distribution](12_random/discrete_distribution.svg)

</diagram>

</div>

Note: A generalization of `uniform_int_distribution`

---

### Piecewise constant distribution

```cpp
template<class RealType = double>
class piecewise_constant_distribution;
```

`$$ p(x \,|\, b_0, \dotsc, b_n, \; \rho_0, \dotsc, \rho_{n-1}) = \rho_i $$`
`$$ \text{for $b_i \le x < b_{i+1}$} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`intervals`|`std::vector<RealType>`|`{0, 1}`|
|`densities`|`std::vector<RealType>`|`{1}`|

</parameters>

![piecewise_constant_distribution](12_random/piecewise_constant_distribution.svg)

</diagram>

</div>

Note: A generalization of `uniform_real_distribution`

---

### Piecewise linear distribution

```cpp
template<class RealType = double>
class piecewise_linear_distribution;
```

`$$ p(x \,|\, b_0, \dotsc, b_n, \; \rho_0, \dotsc, \rho_n) = $$` 
`$$ \rho_{i} \cdot {\frac{b_{i+1} - x}{b_{i+1} - b_i}} + \rho_{i+1} \cdot {\frac{x - b_i}{b_{i+1} - b_i}} $$`
`$$ \text{for $b_i \le x < b_{i+1}$} $$`

</formula>

|parameter|type|default|
|---------|----|-------|
|`intervals`|`std::vector<RealType>`|`{0, 1}`|
|`densities`|`std::vector<RealType>`|`{1}`|

</parameters>

![piecewise_linear_distribution](12_random/piecewise_linear_distribution.svg)

</diagram>

</div>

Note: A generalization of `piecewise_constant_distribution`

---

## example

```cpp
///external
///compiler=g102
///options+=-std=c++2a
///hide
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <random>
#include <vector>

template <int Height = 8, int BarWidth = 5, int Padding = 1, int Offset = 0,
          bool DrawMinMax = true, class Hist>
void draw_vbars(const char* name, Hist const& hist, const int norm) {
    const float cutoff = 0.002f;
    static_assert((Height > 0) && (BarWidth > 0) && (Padding >= 0) && (Offset >= 0));
    auto cout_n = [](auto const& v, int n) { while (n-- > 0) std::cout << v; };

std::vector<float> bars;
    std::vector<int> indices;
    for (const auto [n, p] : hist) {
        if (float x = p * (1.0/norm); cutoff < x) {
            bars.push_back(x);
            indices.push_back(n);
        }
    }

const auto [min, max] = std::minmax_element(std::cbegin(bars), std::cend(bars));
    std::vector<std::div_t> qr;
    for (float e : bars) {
        qr.push_back(std::div(std::lerp(0.f, Height*8, (e - *min)/(*max - *min)), 8));
    }

std::cout << name << ":\n";
    for (auto h{Height}; h-- > 0 ;) {
        cout_n(' ', Offset);
        for (auto [q, r] : qr) {
            char d[] = "█"; // == { 0xe2, 0x96, 0x88, 0 }
            q < h ? d[0] = ' ', d[1] = '\0' : q == h ? d[2] -= (7 - r) : 0;
            cout_n(d, BarWidth);
            cout_n(' ', Padding);
        }
        if (DrawMinMax && Height > 1)
            h == Height - 1 ? std::cout << "┬ " << *max:
                     h != 0 ? std::cout << "│"
                            : std::cout << "┴ " << *min;
        cout_n('\n', 1);
    }
    for (int n : indices) { std::cout << " " << std::setw(2) << n << "   "; }
        cout_n('\n', 2);
}

///unhide
template<typename Engine, typename Distribution>
void generate_and_draw(Engine& gen, Distribution&& d, const char* name) {
    const int norm = 1'00'00;
    std::map<int, int> hist{};
    for (int n=0; n!=norm; ++n) { ++hist[std::round(d(gen))]; }
    draw_vbars(name, hist, norm);
}

///hide
int main() {
///unhide
std::mt19937 gen;
generate_and_draw(gen, std::normal_distribution<>{5,2}, "Normal");
generate_and_draw(gen, std::uniform_real_distribution<>{1.0, 7.0}, "Uniform");
generate_and_draw(gen, std::binomial_distribution<>{4, 0.5}, "Binomial");
generate_and_draw(gen, std::fisher_f_distribution<float>{1.0f, 5.0f}, "Fisher F");
///hide
}
```

---

## standard uniform distribution

```cpp
///hide
#include <random>
#include <iostream>
#include <algorithm>
#include <iterator>
#include <iomanip>

int main() {
///unhide
std::default_random_engine rng;

std::generate_n(std::ostream_iterator<double>{std::cout << std::fixed 
                                                        << std::setprecision(4), 
                                              " "}, 
                8,
                [&rng] { return std::generate_canonical<double, 12>(rng); });

std::cout << '\n';
///hide
}
```

Note: The `generate_canonical` function template provides a standard uniform distribution of floating-point values over the range `[0,1)` with a given number of random bits.

---

## Seeds

Note: An algorithm for random number generation always starts with one or more seeds, which represent the initial input to the calculation that produces the random numbers. The seeds determine the initial state of a random number generator and determine the entire sequence. The number of bits in a seed is significant. With a 1-byte seed, you only have 255 possible values, so you can only produce a maximum of 255 different sequences. To maximize the entropy of a random sequence, you need two things: you need a seed value that is truly random – not pseudo-random, and you need the range of possible values for the seed to be large.

---

## `std::random_device`

```cpp
///hide
#include <random>
#include <iostream>

int main() {
///unhide
std::random_device rd;

std::cout << "rd's range is [" 
          << rd.min() << "," 
          << rd.max() << "]\n";

std::cout << "rd's entropy is " << rd.entropy() << '\n';

std::cout << "generated " << rd() << '\n';
///hide
}
```

Note: Using the OS to gen nondeterministic number from sources such as the times between successive keyboard keystrokes, or intervals between mouse clicks, or the current clock time.

---

## specifying source

```cpp
///hide
///external
#include <random>
#include <iostream>

int main() {
///unhide
std::random_device rd{"/dev/random"};

std::cout << "rd's range is [" 
          << rd.min() << "," 
          << rd.max() << "]\n";

std::cout << "rd's entropy is " << rd.entropy() << '\n';

std::cout << "generated " << rd() << '\n';
///hide
}
```

Note: Differs between implementations. Some of `libstdc++` sources are `rdseed` and `dev/urandom`. Might fall back to a pseudo RNG if no source is available.

---

## seeding a pseudo RNG

```cpp
///hide
///external
#include <random>
#include <iostream>

int main() {
///unhide
std::random_device rd;
std::mt19937 gen{rd()};

std::cout << "generated " << gen() << '\n';
///hide
}
```

Note: As we saw, `mt19937`'s state is 624 words, so seeding it with a 32-bit value limits the possible entropy.

---

## `std::seed_seq`

```cpp [1|3-4]
///hide
#include <random>
#include <vector>
#include <iostream>

int main()
{
///unhide
std::seed_seq seq{1,2,3,4,5};

std::vector<std::uint32_t> seeds(10);
seq.generate(seeds.begin(), seeds.end());

for (std::uint32_t n : seeds) {
  std::cout << n << '\n';
}
///hide
}
```

Note: It consumes a sequence of integer-valued data and produces a requested number of unsigned integer values, based on the consumed data. The produced values are distributed over the entire 32-bit range even if the consumed values are close.
It provides a way to seed a large number of random number engines or to seed a generator that requires a lot of entropy, given a small seed or a poorly distributed initial seed sequence.

---

## initializing RNG

```cpp
///hide
#include <random>
#include <vector>
#include <iostream>

int main()
{
///unhide
std::random_device rd;
std::seed_seq seq{rd(), rd()};
std::mt19937_64{seq};
///hide
}
```

Note: the RNG calls `generate` to initialize its internal state

---

## querying params

```cpp [1-3|5-7]
///hide
#include <random>
#include <iostream>
#include <iterator>
#include <sstream>

int main()
{
///unhide
std::stringstream sst{"-1 0 1"};
std::seed_seq s1(std::istream_iterator<uint32_t>{sst}, 
                 std::istream_iterator<uint32_t>{});

std::cout << "size: " << s1.size() << '\n';
s1.param(std::ostream_iterator<int>(std::cout, " "));
std::cout << '\n';
///hide
}
```

---

## `std::shuffle`

```cpp [4-6]
///hide
#include <random>
#include <algorithm>
#include <iterator>
#include <iostream>
 
int main()
{
///unhide
std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};

std::random_device rd;
std::mt19937 g(rd());

std::shuffle(v.begin(), v.end(), g);

std::copy(v.begin(), v.end(), 
          std::ostream_iterator<int>(std::cout, " "));
std::cout << "\n";
///hide
}
```

Note: a new algorithm for shuffling random access ranges. deprecates `std::random_shuffle` which used `std::rand`.

---

## possible implementation

```cpp [8-13]
///hide
#include <iterator>
#include <random>

///unhide
template<class RandomIt, class URBG>
void shuffle(RandomIt first, RandomIt last, URBG&& g)
{
  typedef typename std::iterator_traits<RandomIt>::difference_type diff_t;
  typedef std::uniform_int_distribution<diff_t> distr_t;
  typedef typename distr_t::param_type param_t;

distr_t D;
  diff_t n = last - first;
  for (diff_t i = n-1; i > 0; --i) {
    using std::swap;
    swap(first[i], first[D(g, param_t(0, i))]);
  }
}
```

Note: the actual implementation is not standardized so different platform might order the range differently.

---

## thank you

----

---

## constant expression

> an expression that can be evaluated at compile time.

---

## local

```cpp
///hide
int main() {
///unhide
const int BOUNDS = 42;
int arr[BOUNDS];
///hide
}
```

---

## member

```cpp
///hide
#include <climits>

///unhide
struct S{
  static const int BIT_WIDTH = 7;
  int data    : BIT_WIDTH;
  int padding : (sizeof(int) * CHAR_BIT - BIT_WIDTH);
};
```

---

## C 
## numeric limits

```cpp
///options+=-std=c++03
#include <climits>

enum Range {
    MIN = 0,
    MAX = INT_MAX
};
```

---

## C++ 
## numeric limits

```cpp
///options+=-std=c++03
///fails='std::numeric_limits<int>::max()' cannot appear in a constant-expression
#include <limits>

enum Range {
    MIN = 0,
    MAX = std::numeric_limits<int>::max()
}
```

---

## flags

```cpp
///options+=-std=c++98
///fails=calls to overloaded operators cannot appear in a constant-expression
enum fmtflags {
  left  = 1 << 0,
  right = 1 << 1
};

inline fmtflags
operator|(fmtflags a, fmtflags b) { 
  return fmtflags(int(a) | int(b)); 
}

enum extendedflags {
  adjust = left | right
};
```

---

## linear algebra

```cpp
///hide
#include <cstddef>

///unhide
template<std::size_t I>
using vector = int[I];

template<std::size_t I>
using matrix_2d = int[I * I];

template<std::size_t I>
using matrix_3d = int[I * I * I];
```

---

## TMP

```cpp
///hide
#include <cstddef>

///unhide
template<std::size_t I, std::size_t D>
struct pow {
  static const auto value = I * pow<I, D - 1>::value;
};

template<std::size_t I>
struct pow<I, 0> {
  static const auto value = 1;
};

template<std::size_t I, std::size_t D>
using matrix = int[pow<I, D>::value];
```

---

# `constexpr`

Note: C++11 introduces a new keyword - `constexpr`, which comes obviously from constant expressions.

---

## `constexpr`

declares that it is *possible* to evaluate the value of a function or a variable at compile time.

---

## example

```cpp
constexpr int getBounds() {
  return 42;
}
int arr[getBounds()];
```

---

## format flags

```cpp
enum fmtflags {
  left  = 1 << 0,
  right = 1 << 1
};

constexpr fmtflags
operator|(fmtflags a, fmtflags b) { 
  return fmtflags(int(a) | int(b)); 
}

enum extendedflags {
  adjust = left | right
};
```

Note: implies inline

---

## C++11   `constexpr`

Source: [N2235](https://wg21.link/n2235), Gabriel Dos Reis, Bjarne Stroustrup, Jens Maurer

Note: while introduced in C+11, `constexpr` gets more and more power with each new standard.
let's first see what was available in the first stage.

---

## C++11 `constexpr` functions

-  return type must be a literal type
-  parameters must be of literal types
-  body must be exactly one <code>return</code> statement
-  any <b>evaluated</b> sub-expression must be a constant expression

Note: evaluated

---

## constant expression

does not include the following

- **undefined behavior**
- calling non `constexpr` functions
- most examinations of `this`
- lambda expressions
- most lvalue-to-rvalue conversions
- referencing uninitialized data
- conversion from `void*` to `object*`
- modification of non-local objects
- comparison with unspecified results
- `type_id` of a polymorphic class
- `dynamic_cast` / `reinterpret_cast`
- `new` / `delete`

Note: undefined behavior

---

## replaces TMP

```cpp
///hide
#include <cstddef>

///unhide
constexpr size_t pow(size_t I, size_t D) {
    return D == 0 ? 1 : I * pow(I, D-1);
}

template<std::size_t I, std::size_t D>
using matrix = int[pow(I, D)];
```

---

## run-time

```cpp
///hide
#include <cstddef>

///unhide
constexpr size_t pow(size_t I, size_t D) {
    return D == 0 ? 1 : I * pow(I, D-1);
}

int main(int argc, const char* argv[]) {
  return pow(argc, 2);
}
```

---

## ignores unevaluated

```cpp [8-16]
///hide
#include <limits>
#include <stdexcept>

///unhide
namespace detail {
template <typename T>
constexpr T next(T num, T prev) {
  return (prev + num / prev) / 2;
}
}  // namespace detail

template <typename T>
constexpr T sqrt(T num, T prev = 1.0) {
  using detail::next;
  return num < 0 
    ? throw std::out_of_range("only non-negative, please")
    : std::abs(next(num, prev) - prev) < std::numeric_limits<T>::epsilon() 
      ? next(num, prev)
      : sqrt(num, next(num, prev));
}

static_assert(std::abs(sqrt(2.0f) - 1.4142135f) < std::numeric_limits<float>::epsilon(), 
              "compile time FTW!");
```

Note: 
- this algorithm is called the Babylonian method
- throw at compile time?
- open CE, change to negative

---

## variables

```cpp [5|1-3,6|1-3,7]
constexpr int value() {
  return 42;
}

///hide
int main() {
///unhide
constexpr double d = 42.5;
constexpr int i = value();
int j = value();
///hide
}
```

Note: for non-`constexpr` variables, the compile can choose whether to compute the initial value at compile time or run time

---

## implies const

```cpp
///fails=assignment of read-only variable 'd'
///hide
int main() {
///unhide
constexpr double d = 42.5;
d = 45.2; // error
///hide
} 
```

---

## C++11 `constexpr` constructor

- parameters must be of literal types
- no body
- must initialize all bases and members

---

## constructor

```cpp []
struct complex {
  constexpr complex(double r, double i) : re(r), im(i) { }
private:
  double re;
  double im;
};

constexpr complex I{0, 1};
```

---

## member functions

```cpp []
///options+=-std=c++11
struct complex {
  constexpr complex(double r, double i) : re(r), im(i) { }
  constexpr double real() { return re; }
  constexpr double imag() { return im; }
private:
  double re;
  double im;
};

constexpr complex I{0, 1};
static_assert(I.imag() == 1, "check");
```

Note: 
- `constexpr` member function implies const 
- we can also access public members

---

## special member functions

```cpp
///options+=-std=c++11
struct S{
  S() = default;
  S(const S&) = default;
  S(S&&) = default;
  S& operator=(const S&) = default;
  S& operator=(S&&) = default;
  ~S() = default;
};
```

Note: open C++ Insights

---

## literal type

either

- scalar (arithmetic, pointer, pointer to member, enumeration, or `std::nullptr_t`)
- reference
- array of literal type
- class that has all the following
  - trivial destructor
  - either
    - an aggregate
    - at least one `constexpr` constructor
  - all non-static data members and base classes are literal 
- for union, at least one member should be a literal

---

## in standard library

```cpp
#include <limits>

enum Range {
    MIN = 0,
    MAX = std::numeric_limits<int>::max()
};
```

---

## in standard library

- `numeric_limits`
- `bitset`
- default constructors of `unique_ptr`, `shared_ptr`, `mutex`
- `chrono::duration`
- `char_traits`
- `complex`
- `array`

Note: for types, it means at least one constructor is `constexpr`, not necessarily all member functions

---

## C++14 relaxed   `constexpr`

Source: [N3597](https://wg21.link/n3597), Richard Smith

Note: for C++14, writing `constexpr` starts to look almost like writing any C++ code.

---

## C++14 `constexpr` functions

can do anything!

except

- `try` / `throw`
- `asm`
- `goto`
- lambda expressions
- non-literal, `static`, `thread-local` or uninitialized variables

---

## `sqrt` revisited

```cpp [1-12]
///hide
#include <limits>
#include <stdexcept>

///unhide
template <typename T>
constexpr T sqrt(T num) {
  if (num < 0) {
    throw std::out_of_range("only non-negative, please");
  }

T prev = 1.0, next = (prev + num / prev) / 2;
  for (; 
       std::abs(next - prev) >= std::numeric_limits<T>::epsilon();
       prev = next, next = (prev + num / prev) / 2);
  return next;
}

static_assert(std::abs(sqrt(2.0f) - 1.4142135f) < std::numeric_limits<float>::epsilon(),
              "compile time FTW!");
```

---

## string switch

```cpp [1-9|11-14|16-25]
///hide
#include <iostream>

void shoot();
void duck();
void run();

///unhide
constexpr unsigned long hash(const char *str) {
    unsigned long hash = 5381;
    
    for (; *str; str++) {
        hash = hash * 33 + *str;
    }

return hash;
}
 
constexpr unsigned long operator"" _sh(
  const char *s, size_t) {
    return hash(s);
}

void on_command(const std::string& cmd) {
    switch (hash(cmd.c_str())) {
        case "shoot"_sh:
            shoot();
        case "duck"_sh:
            duck();
        case "run"_sh:
            run();
    }
}

```

---

## special member functions

```cpp
///options+=-std=c++14
struct S{
  S() = default;
  S(const S&) = default;
  S(S&&) = default;
  S& operator=(const S&) = default;
  S& operator=(S&&) = default;
  ~S() = default;
};
```

Note: open C++ Insights

---

## in standard library

- `initializer_list`
- `forward`,   `move`
- `pair`,   `tuple`
- function objects (`plus`,   `multiplies`,   `equal_to`,   ...)
- `chrono::time_point`
- range access (`begin`,   `end`,   `size`,   ...)
- `min`,   `max`

Note: first two algorithms

---

## `constexpr`   containers and algorithms

Source: Scott Schurr, [`constexpr`: Applications](https://youtu.be/qO-9yiAOQqc), CppCon 2015

Note: with relaxed `constexpr` we can start to unleash the power of compile time calculation by having compile time containers and algorithms to operate on them

---

## binary literals and digit separators (C++14)

The following are identical
```cpp
///hide
void foo() {
int i;
///unhide
i =               4'200;
i =              0x1068;
i =              010150;
i =  0b1'0000'0110'1000;
i = 0b1'000'001'101'000;
///hide
}
```

Note: this first binary notation relates the hexadecimal one, while the second to the octal notation

---

## bit count

```cpp
///hide
#include <cstdint>
#include <cstddef>

///unhide
constexpr size_t count_set_bits(uint32_t x);
```

---

## naive

```cpp
///hide
#include <cstdint>
#include <cstddef>

///unhide
constexpr size_t count_set_bits(uint32_t x) {
  size_t result = 0;
  while (x != 0) {
    x = x & (x - 1);
    result++;
  }
  return result;
}

static_assert(count_set_bits(0x0FF00FF0) == 16, "counted");
```

---

## lookup table

```cpp
///fails=static assertion failed
///hide
#include <cstdint>
#include <cstddef>
#include <array>

///unhide
constexpr size_t count_set_bits(uint32_t x)
{
  constexpr auto bits_set = std::array<uint32_t, 256>{
    /* 0b00, 0b01, 0b10, 0b11, 0b100, 0b101, ... */
          0,    1,    1,    2,     1,     2, 
  };
  return bits_set[ x        & 255]
       + bits_set[(x >>  8) & 255]
       + bits_set[(x >> 16) & 255]
       + bits_set[(x >> 24) & 255];
}

static_assert(count_set_bits(0x0FF00FF0) == 16, "counted");
```

---

## generate lookup

```cpp [1-8|10-16]
///fails=call to non-'constexpr' function
///hide
#include <cstdint>
#include <cstddef>
#include <array>

///unhide
constexpr size_t slow_count(uint32_t x) {
  size_t result = 0;
  while (x != 0) {
    x = x & (x - 1);
    result++;
  }
  return result;
}

constexpr auto generate_bits_set() {
  std::array<uint32_t, 256> res{};
  for (size_t i = 0; i < 256; ++i) {
    res[i] = slow_count(i);
  }
  return res;
}
```

Note: 
- have to init `res`
- fails because non const `std::array::operator[]` is not `constexpr` in c++14

---

## DIY

```cpp []
///hide
#include <cstddef>
#include <iterator>

///unhide
template <typename T, std::size_t N>
class constexpr_array {
public:
  using iterator = T*;

private:
  T m_data[N] {};
};
```

Note:
- all members initialized
- from C++14: non const `constexpr` member function

---

## now

```cpp [2,9]
///fails=call to non-'constexpr' function
///hide
#include <cstdint>
#include <iterator>

template <typename T, std::size_t N>
class constexpr_array {
public:
  using iterator = T*;

private:
  T m_data[N] {};
};

constexpr size_t slow_count(uint32_t x) {
  size_t result = 0;
  while (x != 0) {
    x = x & (x - 1);
    result++;
  }
  return result;
}

///unhide
constexpr auto generate_bits_set() {
  constexpr_array<uint32_t, 256> res{};
  for (size_t i = 0; i < 256; ++i) {
    res[i] = slow_count(i);
  }
  return res;
}

static_assert(generate_bits_set()[3] == 2, "yep");
```

---

## and

```cpp [3,10]
///fails=call to non-'constexpr' function
///hide
#include <cstdint>
#include <iterator>

template <typename T, std::size_t N>
class constexpr_array {
public:
  using iterator = T*;

private:
  T m_data[N] {};
};

constexpr size_t slow_count(uint32_t x) {
  size_t result = 0;
  while (x != 0) {
    x = x & (x - 1);
    result++;
  }
  return result;
}

constexpr auto generate_bits_set() {
  constexpr_array<uint32_t, 256> res{};
  for (size_t i = 0; i < 256; ++i) {
    res[i] = slow_count(i);
  }
  return res;
}

///unhide
constexpr size_t count_set_bits(uint32_t x)
{
  constexpr auto bits_set = generate_bits_set();
  return bits_set[ x        & 255]
       + bits_set[(x >>  8) & 255]
       + bits_set[(x >> 16) & 255]
       + bits_set[(x >> 24) & 255];
}

static_assert(count_set_bits(0x0FF00FF0) == 16, "counted");
```

---

## keep this list sorted

from tar source code

```cpp
///fails='OPTION_B64ENCODE' was not declared in this scope
/*
 * Long options for tar.  Please keep this list sorted.
 *
 * The symbolic names for options that lack a short equivalent are
 * defined in bsdtar.h.  Also note that so far I've found no need
 * to support optional arguments to long options.  That would be
 * a small change to the code below.
 */

static const struct bsdtar_option {
    const char *name;
    int required;      /* 1 if this option requires an argument. */
    int equivalent;    /* Equivalent short option. */
} tar_longopts[] = {
    { "absolute-paths",       0, 'P' },
    { "append",               0, 'r' },
    { "auto-compress",        0, 'a' },
    { "b64encode",            0, OPTION_B64ENCODE },
    { "block-size",           1, 'b' },
    { "bunzip2",              0, 'j' },
    { "bzip",                 0, 'j' },
    { "bzip2",                0, 'j' },
    { "cd",                   1, 'C' },
    { "check-links",          0, OPTION_CHECK_LINKS },
    { "chroot",               0, OPTION_CHROOT },
    { "compress",             0, 'Z' },
    { "confirmation",         0, 'w' },
    { "create",               0, 'c' },
    { "dereference",          0, 'L' },
    { "directory",            1, 'C' },
    { "disable-copyfile",     0, OPTION_DISABLE_COPYFILE },
    { "exclude",              1, OPTION_EXCLUDE },
    { "exclude-from",         1, 'X' },
    { "extract",              0, 'x' },
    { "fast-read",            0, 'q' },
    { "file",                 1, 'f' },
    { "files-from",           1, 'T' },
    { "format",               1, OPTION_FORMAT },
    { "gid",                  1, OPTION_GID },
    { "gname",                1, OPTION_GNAME },
    { "grzip",                0, OPTION_GRZIP },
    { "gunzip",               0, 'z' },
    { "gzip",                 0, 'z' },
    { "help",                 0, OPTION_HELP },
    { "hfsCompression",       0, OPTION_HFS_COMPRESSION },
    { "include",              1, OPTION_INCLUDE },
    { "insecure",             0, 'P' },
    { "interactive",          0, 'w' },
    { "keep-newer-files",     0, OPTION_KEEP_NEWER_FILES },
    { "keep-old-files",       0, 'k' },
    { "list",                 0, 't' },
    { "lrzip",                0, OPTION_LRZIP },
    { "lzip",                 0, OPTION_LZIP },
    { "lzma",                 0, OPTION_LZMA },
    { "lzop",                 0, OPTION_LZOP },
    { "modification-time",    0, 'm' },
    { "newer",                1, OPTION_NEWER_CTIME },
    { "newer-ctime",          1, OPTION_NEWER_CTIME },
    { "newer-ctime-than",     1, OPTION_NEWER_CTIME_THAN },
    { "newer-mtime",          1, OPTION_NEWER_MTIME },
    { "newer-mtime-than",     1, OPTION_NEWER_MTIME_THAN },
    { "newer-than",           1, OPTION_NEWER_CTIME_THAN },
    { "no-recursion",         0, 'n' },
    { "no-same-owner",        0, OPTION_NO_SAME_OWNER },
    { "no-same-permissions",  0, OPTION_NO_SAME_PERMISSIONS },
    { "nodump",               0, OPTION_NODUMP },
    { "nopreserveHFSCompression",0, OPTION_NOPRESERVE_HFS_COMPRESSION },
    { "norecurse",            0, 'n' },
    { "null",                 0, OPTION_NULL },
    { "numeric-owner",        0, OPTION_NUMERIC_OWNER },
    { "older",                1, OPTION_OLDER_CTIME },
    { "older-ctime",          1, OPTION_OLDER_CTIME },
    { "older-ctime-than",     1, OPTION_OLDER_CTIME_THAN },
    { "older-mtime",          1, OPTION_OLDER_MTIME },
    { "older-mtime-than",     1, OPTION_OLDER_MTIME_THAN },
    { "older-than",           1, OPTION_OLDER_CTIME_THAN },
    { "one-file-system",      0, OPTION_ONE_FILE_SYSTEM },
    { "options",              1, OPTION_OPTIONS },
    { "posix",                0, OPTION_POSIX },
    { "preserve-permissions", 0, 'p' },
    { "read-full-blocks",     0, 'B' },
    { "same-owner",           0, OPTION_SAME_OWNER },
    { "same-permissions",     0, 'p' },
    { "strip-components",     1, OPTION_STRIP_COMPONENTS },
    { "to-stdout",            0, 'O' },
    { "totals",               0, OPTION_TOTALS },
    { "uid",                  1, OPTION_UID },
    { "uname",                1, OPTION_UNAME },
    { "uncompress",           0, 'Z' },
    { "unlink",               0, 'U' },
    { "unlink-first",         0, 'U' },
    { "update",               0, 'u' },
    { "use-compress-program", 1, OPTION_USE_COMPRESS_PROGRAM },
    { "uuencode",             0, OPTION_UUENCODE },
    { "verbose",              0, 'v' },
    { "version",              0, OPTION_VERSION },
    { "xz",                   0, 'J' },
    { NULL, 0, 0 }
};
```

---

## let the compiler validate

```cpp
///hide
#include <functional>

///unhide
template<typename ForwardIt, typename Comp = std::less<>>
constexpr bool 
is_sorted(ForwardIt first, ForwardIt last, Comp comp = {}) {
  if (first != last) {
    auto next = first;
    while (++next != last) {
      if (comp(*next, *first))
        return false;
      first = next;
    }
  }
  return true;
}
```

---

## now

```cpp
///hide
#include <functional>

template<typename ForwardIt, typename Comp = std::less<>>
constexpr bool 
is_sorted(ForwardIt first, ForwardIt last, Comp comp = {}) {
  if (first != last) {
    auto next = first;
    while (++next != last) {
      if (comp(*next, *first))
        return false;
      first = next;
    }
  }
  return true;
}

///unhide
template<typename Cont>
constexpr bool is_sorted(Cont&& cont) {
  return is_sorted(std::begin(cont), std::end(cont));
}

constexpr int arr[] = {1, 2, 4, 3};
static_assert(not is_sorted(arr), "checked!");
```

---

## or just sort it

```cpp [7-20]
///hide
#include <functional>

///unhide
template<typename BidirIt>
constexpr auto prev(BidirIt it) {
  auto res = it;
  return --res;
}

template<typename BidirIt, typename Comp = std::less<>>
constexpr void 
sort(BidirIt first, BidirIt last, Comp comp = {}) {
  for (auto it = first; it != last; ++it) {
    auto curr = it;
    const auto temp = *curr;
    for (auto before = prev(curr);
         curr != first && comp(temp, *before);
        --curr, --before) {
      *curr = *before;
    }
    *curr = temp;
  }
}
```

Note: this is an insertion sort, but more complex sorting algorithms can also be implemented

---

## now

```cpp [1-9|11-13]
///options+=-std=c++17
///hide
#include <functional>

template<typename BidirIt>
constexpr auto prev(BidirIt it) {
  auto res = it;
  return --res;
}

template<typename Cont>
constexpr bool is_sorted(Cont&& cont) {
  return is_sorted(std::begin(std::forward<Cont>(cont)), std::end(std::forward<Cont>(cont)));
}

template <typename T, std::size_t N>
class constexpr_array {
public:
  using iterator = T*;
  using const_iterator = const T*;

constexpr std::size_t size() const { return N; }
  constexpr T& operator[](std::size_t n) { return m_data[n]; }
  constexpr const T& operator[](std::size_t n) const { return m_data[n]; }
  constexpr iterator begin() { return std::begin(m_data); }
  constexpr iterator end() { return std::end(m_data); }
  constexpr const_iterator begin() const { return std::begin(m_data); }
  constexpr const_iterator end() const { return std::end(m_data); }

private:
  T m_data[N] {};
};

///unhide
template<typename T, size_t N>
constexpr auto sort(const T(& cont)[N]) {
  constexpr_array<T, N> sorted;
  for (size_t i = 0; i < N; ++i) {
      sorted[i] = cont[i];
  }
  sort(sorted.begin(), sorted.end());
  return sorted;
}

constexpr int arr[] = {1, 2, 4, 3};
constexpr auto sorted = sort(arr);
static_assert(is_sorted(sorted), "checked");
```

Note:
compile time map

---

## associative containers

```cpp [1-2,30|3,9-15|23-29]
///hide
#include <functional>
#include <stdexcept>

template<typename BidirIt, typename Comp = std::less<>>
constexpr void 
sort(BidirIt first, BidirIt last, Comp comp = {});

template<class InputIt, class OutputIt>
constexpr OutputIt copy(InputIt first, InputIt last, OutputIt d_first);

template<size_t N, class ForwardIt, class T, class Compare = std::less<>>
constexpr ForwardIt lower_bound(ForwardIt first, const T& value, Compare comp = {});

///unhide
template <typename T, std::size_t N>
class constexpr_set {
  T m_data[N] {};

public:
  using iterator = T*;
  using const_iterator = const T*;

constexpr constexpr_set(std::initializer_list<T> list) {
    if (list.size() != N) {
      throw std::logic_error("size mismatch");
    }
    copy(list.begin(), list.end(), m_data);
    sort(begin(), end());
  }
  constexpr std::size_t size() const { return N; }
  constexpr T& operator[](std::size_t n) { return m_data[n]; }
  constexpr const T& operator[](std::size_t n) const { return m_data[n]; }
  constexpr iterator begin() { return std::begin(m_data); }
  constexpr iterator end() { return std::end(m_data); }
  constexpr const_iterator begin() const { return std::begin(m_data); }
  constexpr const_iterator end() const { return std::end(m_data); }
  constexpr const_iterator find(const T& value) const { 
    auto it = lower_bound<N>(begin(), value);
    if (it != end() && !(value < *it)) {
      return it;
    }
    return end();
  }
};
```

---

## `lower_bound`

```cpp [1-4,15|5-7|9-14]
///hide
#include <cstddef>
#include <functional>

///unhide
template<size_t N, class ForwardIt, class T, class Compare = std::less<>>
constexpr ForwardIt lower_bound(ForwardIt first, const T& value, 
                                Compare comp = {})
{
  if (N == 0) {
    return first;
  }

constexpr auto half = N / 2;
  auto it = first + half;
  if (comp(*it, value)) {
      return lower_bound<N - (half + 1)>(next(it), value, comp);
  }
  return lower_bound<half>(first, value);
}
```

Note: take only a first iterator because size is templated, which generates better code than passing size as a parameter

---

## benchmark

```cpp
///external
///options=-std=c++14 -O3
///compiler=clang1000
///libs=benchmark:150
///hide
#include <benchmark/benchmark.h>
#include <functional>
#include <set>
#include <stdexcept>

template<typename BidirIt>
constexpr auto next(BidirIt it) {
  return ++it;
}

template<typename BidirIt>
constexpr auto prev(BidirIt it) {
  return --it;
}

template<typename BidirIt, typename Comp = std::less<>>
constexpr void 
sort(BidirIt first, BidirIt last, Comp comp = {}) {
  if (first == last) {
    return;
  }

for (auto it = next(first); it != last; ++it) {
    auto curr = it;
    const auto temp = *curr;
    for (auto before = prev(curr);
         curr != first && comp(temp, *before);
        --curr, --before) {
      *curr = *before;
    }
    *curr = temp;
  }
}

template<size_t N, class ForwardIt, class T, class Compare = std::less<>>
constexpr ForwardIt lower_bound(ForwardIt first, const T& value, Compare comp = {})
{
  if (N == 0) {
    return first;
  }

constexpr auto half = N / 2;
  auto it = first + half;
  if (comp(*it, value)) {
      return lower_bound<N - (half + 1)>(next(it), value, comp);
  }
  return lower_bound<half>(first, value);
}

template<class InputIt, class OutputIt>
constexpr OutputIt copy(InputIt first, InputIt last, 
              OutputIt d_first)
{
    while (first != last) {
        *d_first++ = *first++;
    }
    return d_first;
}

template <typename T, std::size_t N>
class constexpr_set {
public:
  using iterator = T*;
  using const_iterator = const T*;

constexpr constexpr_set(std::initializer_list<T> list) {
    if (list.size() != N) {
      throw std::logic_error("size mismatch");
    }
    copy(list.begin(), list.end(), m_data);
    sort(std::begin(m_data), std::end(m_data));
  }
  constexpr std::size_t size() const { return N; }
  constexpr T& operator[](std::size_t n) { return m_data[n]; }
  constexpr const T& operator[](std::size_t n) const { return m_data[n]; }
  constexpr iterator begin() { return std::begin(m_data); }
  constexpr iterator end() { return std::end(m_data); }
  constexpr const_iterator begin() const { return std::begin(m_data); }
  constexpr const_iterator end() const { return std::end(m_data); }
  constexpr const_iterator find(const T& value) const { 
    auto it = lower_bound<N>(begin(), value, std::less<>{});
    if (it != end() && !(value < *it)) {
      return it;
    }
    return end();
  }

private:
  T m_data[N] {};
};

///unhide
static constexpr constexpr_set<int, 32> constexprSet{
  0, 2, 4, 6, 8, 10, 12, 14,
  16, 18, 20, 22, 24, 26, 28, 30,
  32, 34, 36, 38, 40, 42, 44, 46,
  48, 50, 52, 54, 56, 58, 60, 62
};

static void ConstexprSet(benchmark::State& state) {
  for (auto _ : state) {
    for (int i = 0; i < 50; ++i) {
      volatile bool status = constexprSet.find(i) != constexprSet.end();
      benchmark::DoNotOptimize(status);
    }
  }
}
BENCHMARK(ConstexprSet);

static const std::set<int> stdSet(constexprSet.begin(), constexprSet.end());

static void StdSet(benchmark::State& state) {
  for (auto _ : state) {
    for (int i = 0; i < 50; ++i) {
      volatile bool status = stdSet.find(i) != stdSet.end();
      benchmark::DoNotOptimize(status);
    }
  }
}
BENCHMARK(StdSet);

///hide
BENCHMARK_MAIN();
```

---

## testing

```cpp
///libs=catch2:2110
///hide
#include <functional>
#include <set>
#include <stdexcept>
//#define CATCH_CONFIG_MAIN
///unhide
#include <catch.hpp>

///hide
template<typename BidirIt>
constexpr auto next(BidirIt it) {
  return ++it;
}

template<typename BidirIt>
constexpr auto prev(BidirIt it) {
  return --it;
}

template<typename BidirIt, typename Comp = std::less<>>
constexpr void 
sort(BidirIt first, BidirIt last, Comp comp = {}) {
  if (first == last) {
    return;
  }

template<size_t N, class ForwardIt, class T, class Compare = std::less<>>
constexpr ForwardIt lower_bound(ForwardIt first, const T& value, Compare comp = {})
{
  if (N == 0) {
    return first;
  }

constexpr auto half = N / 2;
  auto it = first + half;
  if (comp(*it, value)) {
      return lower_bound<N - (half + 1)>(next(it), value, comp);
  }
  return lower_bound<half>(first, value);
}

template <typename T, std::size_t N>
class constexpr_set {
public:
  using iterator = T*;
  using const_iterator = const T*;

constexpr constexpr_set(std::initializer_list<T> list) {
    if (list.size() != N) {
      throw std::logic_error("size mismatch");
    }
    copy(list.begin(), list.end(), m_data);
    sort(std::begin(m_data), std::end(m_data));
  }
  constexpr std::size_t size() const { return N; }
  constexpr T& operator[](std::size_t n) { return m_data[n]; }
  constexpr const T& operator[](std::size_t n) const { return m_data[n]; }
  constexpr iterator begin() { return std::begin(m_data); }
  constexpr iterator end() { return std::end(m_data); }
  constexpr const_iterator begin() const { return std::begin(m_data); }
  constexpr const_iterator end() const { return std::end(m_data); }
  constexpr const_iterator find(const T& value) const { 
    auto it = lower_bound<N>(begin(), value, std::less<>{});
    if (it != end() && !(value < *it)) {
      return it;
    }
    return end();
  }

private:
  T m_data[N] {};
};

///unhide
static constexpr constexpr_set<int, 32> constexprSet{
  0, 2, 4, 6, 8, 10, 12, 14,
  16, 18, 20, 22, 24, 26, 28, 30,
  32, 34, 36, 38, 40, 42, 44, 46,
  48, 50, 52, 54, 56, 58, 60, 62
};

TEST_CASE("test constexpr set") {
    STATIC_REQUIRE(constexprSet.find(1) == constexprSet.end());
    STATIC_REQUIRE(constexprSet.find(42) != constexprSet.end());
    STATIC_REQUIRE(constexprSet.find(100) == constexprSet.end());
}
```

---

## unordered containers

![hash](11_containers/hash.svg)

---

## minimal perfect hash

![perfect hash](13_constexpr/hash_perfect.svg)

Note: how to generate a perfect hash?

---

## minimal perfect hash step 0

![condensed hash](13_constexpr/hash_condensed.svg)

Note: hash table size will be number of elements

---

## helper hash

```cpp
///hide
#include <cstddef>

///unhide
template<typename Key>
std::size_t helper_hash(const Key& key, 
                        const std::size_t seed);
```

---

## minimal perfect hash step 1

![first bucket hash](13_constexpr/hash_first_bucket.svg)

`helper_hash("Sandra Dee", 5123) == 0`
`helper_hash("John Smith", 5123) == 3`

Note: starting with the largest bucket we randomly find a seed such that all the bucket
elements map to distinct free slots

---

## minimal perfect hash step 2

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
   xmlns:dc="http://purl.org/dc/elements/1.1/"
   xmlns:cc="http://creativecommons.org/ns#"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   width="628.94153"
   height="369.85919"
   id="fig"
   stroke-linejoin="round"
   stroke-opacity="1"
   stroke-linecap="round"
   fill-opacity="1"
   fill-rule="evenodd"
   font-family="'Bitstream Courier'"
   font-style="normal"
   font-weight="normal"
   pagecolor="#ffff00"
   pageopacity="0.0"
   version="1.1"
   sodipodi:docname="hash_second_bucket.svg"
   inkscape:version="1.0 (4035a4f, 2020-05-01)">
  <metadata
     id="metadata1543">
    <rdf:RDF>
      <cc:Work
         rdf:about="">
        <dc:format>image/svg+xml</dc:format>
        <dc:type
           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
        <dc:title></dc:title>
      </cc:Work>
    </rdf:RDF>
  </metadata>
  <defs
     id="defs1541">
    <defs
       id="defs1270">
      
      <marker
         orient="auto"
         markerHeight="8"
         markerWidth="8"
         refY="4"
         refX="4"
         viewBox="0 0 8 8"
         id="linkdot_N">
        <circle
           id="circle1240"
           fill="#000000"
           stroke="#000000"
           r="3"
           cy="4"
           cx="4" />
      </marker>
      
      <marker
         orient="auto"
         markerHeight="8"
         markerWidth="8"
         refY="4"
         refX="4"
         viewBox="0 0 8 8"
         id="linkdot_U">
        <line
           id="line1243"
           stroke="#000000"
           y2="7"
           x2="7"
           y1="1"
           x1="1" />
        <line
           id="line1245"
           stroke="#000000"
           y2="1"
           x2="7"
           y1="7"
           x1="1" />
      </marker>
      
      <marker
         orient="auto"
         markerHeight="8"
         markerWidth="14"
         refY="4"
         refX="13"
         viewBox="0 0 14 8"
         id="arrowtip_N">
        <polygon
           id="polygon1248"
           fill="#000000"
           stroke="#000000"
           points="1,7 1,4 1,1 13,4 " />
      </marker>
      
      <marker
         orient="auto"
         markerHeight="8"
         markerWidth="14"
         refY="4"
         refX="13"
         viewBox="0 0 14 8"
         id="arrowtip_C">
        <polygon
           id="polygon1251"
           fill="#cc0000"
           stroke="#cc0000"
           points="1,7 1,4 1,1 13,4 " />
      </marker>
      
      <rect
         stroke="none"
         fill="#00ffff"
         height="20"
         width="90"
         x="0"
         y="0"
         id="key_box_N" />
      
      <rect
         stroke="none"
         fill="#00ffff"
         height="20"
         width="90"
         x="0"
         y="0"
         id="key_box_C" />
      
      <rect
         stroke="#000000"
         fill="#9cff9c"
         height="20"
         width="90"
         x="0"
         y="0"
         id="key_box_E" />
      
      <rect
         stroke="#000000"
         fill="#ddeedd"
         height="20"
         width="90"
         x="0"
         y="0"
         id="key_box_U" />
      
      <rect
         stroke="#000000"
         fill="#9cff9c"
         height="20"
         width="80"
         x="0"
         y="0"
         id="val_box_E" />
      
      <rect
         stroke="#000000"
         fill="#ddeedd"
         height="20"
         width="80"
         x="0"
         y="0"
         id="val_box_U" />
      
      <rect
         stroke="#000000"
         fill="#9cff9c"
         height="20"
         width="20"
         x="0"
         y="0"
         id="ptr_box_E" />
      
      <rect
         stroke="#000000"
         fill="#ddeedd"
         height="20"
         width="20"
         x="0"
         y="0"
         id="ptr_box_U" />
      
      <rect
         stroke="none"
         fill="#ddeedd"
         height="18"
         width="34"
         y="1"
         x="3"
         id="hsh_box_U" />
      
      <rect
         stroke="none"
         fill="#a8a8ff"
         height="18"
         width="34"
         y="1"
         x="3"
         id="hsh_box_N" />
      
      <rect
         stroke="none"
         fill="#ee4444"
         height="18"
         width="34"
         y="1"
         x="3"
         id="hsh_box_C" />
      
      <g
         id="vdots">
        <rect
           id="rect1265"
           height="2"
           width="2"
           y="6"
           x="0" />
        <rect
           id="rect1267"
           height="2"
           width="2"
           y="12"
           x="0" />
      </g>
    </defs>
    <rect
       x="33.741165"
       y="105.34306"
       width="19.028448"
       height="13.339531"
       id="rect5462" />
    <rect
       x="33.741165"
       y="105.34306"
       width="19.028448"
       height="13.339531"
       id="rect5815" />
    <marker
       orient="auto"
       markerHeight="8"
       markerWidth="14"
       refY="4"
       refX="13"
       viewBox="0 0 14 8"
       id="arrowtip_C-8">
      <polygon
         id="polygon1251-4"
         fill="#cc0000"
         stroke="#cc0000"
         points="1,1 13,4 1,7 1,4 " />
    </marker>
    <marker
       orient="auto"
       markerHeight="8"
       markerWidth="14"
       refY="4"
       refX="13"
       viewBox="0 0 14 8"
       id="marker7028">
      <polygon
         id="polygon7026"
         fill="#cc0000"
         stroke="#cc0000"
         points="1,1 13,4 1,7 1,4 " />
    </marker>
    <rect
       id="rect6030"
       height="13.339531"
       width="19.028448"
       y="105.34306"
       x="33.741165" />
    <rect
       id="rect7136"
       height="13.339531"
       width="19.028448"
       y="105.34306"
       x="33.741165" />
    <marker
       orient="auto"
       markerHeight="8"
       markerWidth="14"
       refY="4"
       refX="13"
       viewBox="0 0 14 8"
       id="arrowtip_N-9">
      <polygon
         id="polygon1248-6"
         fill="#000000"
         stroke="#000000"
         points="1,4 1,1 13,4 1,7 " />
    </marker>
  </defs>
  <sodipodi:namedview
     inkscape:document-rotation="0"
     pagecolor="#ffffff"
     bordercolor="#666666"
     borderopacity="1"
     objecttolerance="10"
     gridtolerance="10"
     guidetolerance="10"
     inkscape:pageopacity="0"
     inkscape:pageshadow="2"
     inkscape:window-width="1680"
     inkscape:window-height="1005"
     id="namedview1539"
     showgrid="false"
     fit-margin-top="0"
     fit-margin-left="0"
     fit-margin-right="0"
     fit-margin-bottom="0"
     inkscape:zoom="1.1690673"
     inkscape:cx="294.05839"
     inkscape:cy="267.11451"
     inkscape:window-x="1768"
     inkscape:window-y="38"
     inkscape:window-maximized="0"
     inkscape:current-layer="fig" />
  <text
     id="text3252"
     stroke="none"
     fill="#000000"
     font-weight="bold"
     font-size="15px"
     y="11.396484"
     x="140.97322"
     style="text-anchor:middle">hash</text>
  <text
     id="text3254"
     stroke="none"
     fill="#000000"
     font-weight="bold"
     font-size="15px"
     y="31.396482"
     x="140.97322"
     style="text-anchor:middle">function</text>
  <rect
     id="rect3256"
     stroke="none"
     fill="#aaeecc"
     height="237.94626"
     width="60"
     y="40.206467"
     x="110.97322"
     style="font-size:12px;text-anchor:middle;stroke-width:1.21949" />
  <g
     aria-label="keys"
     id="text1272"
     style="font-weight:bold;font-size:15px;text-anchor:middle;fill:#000000;stroke:none"
     transform="translate(0,41.101313)">
    <path
       d="m 35.625,-10 h -3.068848 l -2.307129,-3.581543 -0.717773,0.871582 V -10 h -2.636719 v -11.396484 h 2.636719 v 6.804199 l 2.841797,-3.632813 h 3.039551 l -2.958985,3.544922 z"
       style="font-weight:bold;font-size:15px;fill:#000000;stroke:none"
       id="path2202" />
    <path
       d="m 45.073242,-13.625488 h -6.035156 q 0.05859,0.966797 0.732422,1.479492 0.681152,0.512695 1.999512,0.512695 0.83496,0 1.618652,-0.300293 0.783691,-0.300293 1.237793,-0.644531 h 0.292969 v 2.116699 q -0.893555,0.358887 -1.684571,0.5200197 -0.791015,0.1611329 -1.750488,0.1611329 -2.475586,0 -3.793945,-1.1132816 -1.31836,-1.113281 -1.31836,-3.171386 0,-2.036133 1.245117,-3.222657 1.252442,-1.193847 3.427735,-1.193847 2.006836,0 3.017578,1.018066 1.010742,1.010742 1.010742,2.915039 z m -2.62207,-1.54541 q -0.02197,-0.827637 -0.410156,-1.245118 -0.388184,-0.41748 -1.208496,-0.41748 -0.761719,0 -1.252442,0.395508 -0.490723,0.395508 -0.549316,1.26709 z"
       style="font-weight:bold;font-size:15px;fill:#000000;stroke:none"
       id="path2204" />
    <path
       d="m 50.646973,-12.907715 1.875,-5.317383 h 2.709961 l -4.570313,11.2426761 h -2.856445 l 1.303711,-3.0761721 -3.200684,-8.166504 h 2.768555 z"
       style="font-weight:bold;font-size:15px;fill:#000000;stroke:none"
       id="path2206" />
    <path
       d="m 63.837891,-12.607422 q 0,1.274414 -1.142579,2.058106 -1.142578,0.7763668 -3.127441,0.7763668 -1.098633,0 -1.992187,-0.2050781 -0.893555,-0.2050777 -1.435547,-0.4541017 v -2.167969 h 0.241699 q 0.197754,0.13916 0.454101,0.307618 0.263672,0.161132 0.739747,0.351562 0.410156,0.168457 0.930175,0.292969 0.52002,0.117187 1.113282,0.117187 0.776367,0 1.149902,-0.168457 0.373535,-0.175781 0.373535,-0.512695 0,-0.300293 -0.219726,-0.432129 -0.219727,-0.13916 -0.834961,-0.263672 -0.292969,-0.06592 -0.79834,-0.13916 -0.498047,-0.08057 -0.908203,-0.19043 -1.120606,-0.292968 -1.662598,-0.908203 -0.541992,-0.622558 -0.541992,-1.54541 0,-1.186523 1.120605,-1.970215 1.12793,-0.791015 3.076172,-0.791015 0.922852,0 1.765137,0.190429 0.849609,0.183106 1.325683,0.395508 v 2.080078 h -0.22705 q -0.585938,-0.402832 -1.340332,-0.651855 -0.747071,-0.256348 -1.516114,-0.256348 -0.637207,0 -1.07666,0.175781 -0.432129,0.175782 -0.432129,0.498047 0,0.292969 0.197754,0.446778 0.197754,0.153808 0.930176,0.307617 0.402832,0.08057 0.864258,0.161133 0.46875,0.07324 0.9375,0.190429 1.040039,0.270996 1.538086,0.856934 0.498047,0.578613 0.498047,1.450195 z"
       style="font-weight:bold;font-size:15px;fill:#000000;stroke:none"
       id="path2208" />
  </g>
  <path
     d="m 0,71.101313 h 90 v 20 H 0 Z"
     style="font-size:12px;text-anchor:middle;fill:#00ffff;stroke:none"
     id="use1274" />
  <g
     style="font-size:12px;text-anchor:middle;stroke:none"
     id="text1276"
     aria-label="John Smith"
     transform="translate(0,71.101313)">
    <path
       id="path2212"
       style="stroke:none"
       d="m 15.539063,11.732422 q 0,1.148437 -0.703125,1.769531 -0.697266,0.621094 -1.875,0.621094 -0.28125,0 -0.75,-0.05273 -0.46875,-0.04687 -0.785157,-0.117188 v -1.083984 h 0.06445 q 0.240235,0.08203 0.591797,0.169922 0.351563,0.08789 0.720703,0.08789 0.539063,0 0.855469,-0.123047 0.322266,-0.123047 0.47461,-0.351562 0.158203,-0.234375 0.199218,-0.574219 0.04687,-0.339844 0.04687,-0.785156 V 6.2011719 H 12.533203 V 5.2753906 h 3.00586 z" />
    <path
       id="path2214"
       style="stroke:none"
       d="m 23.291016,10.730469 q 0,1.599609 -0.820313,2.52539 -0.820312,0.925782 -2.197266,0.925782 -1.388671,0 -2.208984,-0.925782 Q 17.25,12.330078 17.25,10.730469 q 0,-1.5996096 0.814453,-2.5253909 0.820313,-0.9316406 2.208984,-0.9316406 1.376954,0 2.197266,0.9316406 0.820313,0.9257813 0.820313,2.5253909 z m -1.136719,0 q 0,-1.2714846 -0.498047,-1.886719 -0.498047,-0.6210937 -1.382813,-0.6210937 -0.896484,0 -1.394531,0.6210937 -0.492187,0.6152344 -0.492187,1.886719 0,1.230469 0.498047,1.86914 0.498046,0.632813 1.388671,0.632813 0.878907,0 1.376954,-0.626953 0.503906,-0.632813 0.503906,-1.875 z" />
    <path
       id="path2216"
       style="stroke:none"
       d="m 30.474609,14 h -1.101562 v -3.726562 q 0,-0.4511724 -0.05273,-0.8437505 Q 29.267578,9.03125 29.126953,8.8085938 28.980469,8.5625 28.705078,8.4453125 28.429687,8.3222656 27.990234,8.3222656 q -0.451172,0 -0.943359,0.2226563 -0.492188,0.2226562 -0.943359,0.5683594 V 14 H 25.001953 V 4.8828125 h 1.101563 v 3.2988281 q 0.515625,-0.4277344 1.066406,-0.6679687 0.550781,-0.2402344 1.130859,-0.2402344 1.060547,0 1.617188,0.6386719 0.55664,0.6386719 0.55664,1.8398437 z" />
    <path
       id="path2218"
       style="stroke:none"
       d="m 38.068359,14 h -1.101562 v -3.726562 q 0,-0.4511724 -0.05273,-0.8437505 Q 36.861328,9.03125 36.720703,8.8085938 36.574219,8.5625 36.298828,8.4453125 36.023437,8.3222656 35.583984,8.3222656 q -0.451172,0 -0.943359,0.2226563 -0.492188,0.2226562 -0.943359,0.5683594 V 14 H 32.595703 V 7.4550781 h 1.101563 v 0.7265625 q 0.515625,-0.4277344 1.066406,-0.6679687 0.550781,-0.2402344 1.130859,-0.2402344 1.060547,0 1.617188,0.6386719 0.55664,0.6386719 0.55664,1.8398437 z" />
    <path
       id="path2220"
       style="stroke:none"
       d="m 50.835937,11.509766 q 0,0.509765 -0.240234,1.007812 -0.234375,0.498047 -0.662109,0.84375 -0.46875,0.375 -1.095703,0.585938 -0.621094,0.210937 -1.5,0.210937 -0.94336,0 -1.699219,-0.175781 -0.75,-0.175781 -1.529297,-0.521484 v -1.453125 h 0.08203 q 0.66211,0.550781 1.529297,0.849609 0.867188,0.298828 1.628906,0.298828 1.078125,0 1.675782,-0.404297 0.603515,-0.404297 0.603515,-1.078125 0,-0.580078 -0.287109,-0.855469 -0.28125,-0.27539 -0.861328,-0.427734 -0.439453,-0.117187 -0.955078,-0.193359 -0.509766,-0.07617 -1.083985,-0.19336 Q 45.28125,9.7578125 44.71875,9.1660156 44.162109,8.5683594 44.162109,7.6132812 q 0,-1.0957031 0.925782,-1.7929687 0.925781,-0.703125 2.349609,-0.703125 0.919922,0 1.6875,0.1757812 0.767578,0.1757813 1.359375,0.4335938 v 1.3710937 h -0.08203 q -0.498047,-0.421875 -1.3125,-0.6972656 -0.808594,-0.28125 -1.658203,-0.28125 -0.931641,0 -1.5,0.3867188 -0.5625,0.3867187 -0.5625,0.9960937 0,0.5449219 0.28125,0.8554688 0.28125,0.3105469 0.990234,0.4746094 0.375,0.082031 1.066406,0.1992187 0.691406,0.1171875 1.171875,0.2402344 0.972656,0.2578125 1.464844,0.7792966 0.492187,0.521485 0.492186,1.458985 z" />
    <path
       id="path2222"
       style="stroke:none"
       d="m 62.162109,14 h -1.101562 v -3.726562 q 0,-0.4218755 -0.04102,-0.8144536 Q 60.984375,9.0664063 60.861328,8.8320313 60.726562,8.5800781 60.474609,8.4511719 60.222656,8.3222656 59.748047,8.3222656 q -0.462891,0 -0.925781,0.234375 -0.462891,0.2285157 -0.925782,0.5859375 0.01758,0.1347657 0.0293,0.3164063 0.01172,0.1757812 0.01172,0.3515625 V 14 h -1.101563 v -3.726562 q 0,-0.4335942 -0.04102,-0.820313 Q 56.759766,9.0605469 56.636719,8.8261719 56.501953,8.5742188 56.25,8.4511719 55.998047,8.3222656 55.523437,8.3222656 q -0.451171,0 -0.908203,0.2226563 -0.451172,0.2226562 -0.902343,0.5683594 V 14 H 52.611328 V 7.4550781 h 1.101563 v 0.7265625 q 0.515625,-0.4277344 1.02539,-0.6679687 0.515625,-0.2402344 1.095703,-0.2402344 0.667969,0 1.13086,0.28125 0.46875,0.28125 0.697265,0.7792969 0.667969,-0.5625 1.21875,-0.8085938 0.550782,-0.2519531 1.177735,-0.2519531 1.078125,0 1.58789,0.65625 0.515625,0.6503906 0.515625,1.8222656 z" />
    <path
       id="path2224"
       style="stroke:none"
       d="M 65.466797,6.359375 H 64.224609 V 5.2167969 h 1.242188 z M 65.396484,14 H 64.294922 V 7.4550781 h 1.101562 z" />
    <path
       id="path2226"
       style="stroke:none"
       d="m 70.986328,13.941406 q -0.310547,0.08203 -0.679687,0.134766 -0.363282,0.05273 -0.650391,0.05273 -1.001953,0 -1.523438,-0.539062 -0.521484,-0.539063 -0.521484,-1.728516 V 8.3808594 H 66.867187 V 7.4550781 h 0.744141 V 5.5742187 h 1.101563 v 1.8808594 h 2.273437 v 0.9257813 h -2.273437 v 2.9824216 q 0,0.515625 0.02344,0.808594 0.02344,0.287109 0.164063,0.539063 0.128906,0.234375 0.351562,0.345703 0.228516,0.105468 0.691406,0.105468 0.269532,0 0.5625,-0.07617 0.292969,-0.08203 0.421875,-0.134766 h 0.05859 z" />
    <path
       id="path2228"
       style="stroke:none"
       d="m 77.794922,14 h -1.101563 v -3.726562 q 0,-0.4511724 -0.05273,-0.8437505 Q 76.587891,9.03125 76.447266,8.8085938 76.300781,8.5625 76.025391,8.4453125 75.75,8.3222656 75.310547,8.3222656 q -0.451172,0 -0.94336,0.2226563 Q 73.875,8.7675781 73.423828,9.1132813 V 14 H 72.322266 V 4.8828125 h 1.101562 v 3.2988281 q 0.515625,-0.4277344 1.066406,-0.6679687 0.550782,-0.2402344 1.13086,-0.2402344 1.060547,0 1.617187,0.6386719 0.556641,0.6386719 0.556641,1.8398437 z" />
  </g>
  <path
     d="m 95,81.101313 h 5"
     style="font-size:12px;text-anchor:middle;stroke:#dd0000"
     id="line1278" />
  <path
     d="m 100,81.101313 30,69.999997"
     style="font-size:12px;text-anchor:middle;stroke:#dd0000"
     id="line1280" />
  <path
     d="m 130.63751,151.10131 h 45.50041"
     style="font-size:12px;text-anchor:middle;stroke:#dd0000;stroke-width:1.50832;marker-end:url(#arrowtip_C)"
     id="line1282" />
  <path
     d="m 0,111.10131 h 90 v 20 H 0 Z"
     style="font-size:12px;text-anchor:middle;fill:#00ffff;stroke:none"
     id="use1286" />
  <g
     style="font-size:12px;text-anchor:middle;stroke:none"
     id="text1288"
     aria-label="Lisa Smith"
     transform="translate(0,111.10131)">
    <path
       id="path2235"
       style="stroke:none"
       d="M 20.097656,14 H 14.578125 V 5.2753906 h 1.160156 V 12.96875 h 4.359375 z" />
    <path
       id="path2237"
       style="stroke:none"
       d="M 22.353516,6.359375 H 21.111328 V 5.2167969 h 1.242188 z M 22.283203,14 H 21.181641 V 7.4550781 h 1.101562 z" />
    <path
       id="path2239"
       style="stroke:none"
       d="m 29.150391,12.113281 q 0,0.896485 -0.744141,1.470703 -0.738281,0.574219 -2.021484,0.574219 -0.726563,0 -1.335938,-0.169922 -0.603516,-0.175781 -1.013672,-0.380859 v -1.236328 h 0.05859 q 0.521484,0.392578 1.160156,0.626953 0.638672,0.228516 1.22461,0.228516 0.726562,0 1.136718,-0.234375 0.410157,-0.234375 0.410157,-0.738282 0,-0.386718 -0.222657,-0.585937 -0.222656,-0.199219 -0.855468,-0.339844 -0.234375,-0.05273 -0.615235,-0.123047 -0.375,-0.07031 -0.685547,-0.152344 -0.861328,-0.228515 -1.224609,-0.667968 -0.357422,-0.4453129 -0.357422,-1.0898441 0,-0.4042969 0.164063,-0.7617188 0.169921,-0.3574218 0.509765,-0.6386719 0.328125,-0.2753906 0.832031,-0.4335937 0.509766,-0.1640625 1.136719,-0.1640625 0.585938,0 1.183594,0.1464844 0.603516,0.140625 1.001953,0.3457031 v 1.1777344 h -0.05859 Q 28.412109,8.65625 27.808594,8.4453125 27.205078,8.2285156 26.625,8.2285156 q -0.603516,0 -1.019531,0.234375 -0.416016,0.2285157 -0.416016,0.6855469 0,0.4042969 0.251953,0.609375 0.246094,0.2050781 0.796875,0.3339845 0.304688,0.07031 0.679688,0.140625 0.380859,0.07031 0.632812,0.128906 0.767578,0.175781 1.183594,0.603516 0.416016,0.433594 0.416016,1.148437 z" />
    <path
       id="path2241"
       style="stroke:none"
       d="m 35.818359,14 h -1.095703 v -0.697266 q -0.146484,0.09961 -0.398437,0.28125 -0.246094,0.175782 -0.480469,0.28125 Q 33.568359,14 33.210937,14.087891 q -0.357421,0.09375 -0.83789,0.09375 -0.884766,0 -1.5,-0.585938 -0.615235,-0.585937 -0.615235,-1.49414 0,-0.744141 0.316407,-1.201172 0.322265,-0.462891 0.914062,-0.726563 0.597656,-0.2636717 1.435547,-0.3574217 0.837891,-0.09375 1.798828,-0.140625 V 9.5058594 q 0,-0.375 -0.134765,-0.6210938 -0.128907,-0.2460937 -0.375,-0.3867187 -0.234375,-0.1347656 -0.5625,-0.1816406 -0.328125,-0.046875 -0.685547,-0.046875 -0.433594,0 -0.966797,0.1171875 -0.533203,0.1113281 -1.101563,0.328125 h -0.05859 V 7.5957031 q 0.322265,-0.087891 0.93164,-0.1933594 0.609375,-0.1054687 1.201172,-0.1054687 0.691406,0 1.201172,0.1171875 0.515625,0.1113281 0.890625,0.3867187 0.369141,0.2695313 0.5625,0.6972657 0.193359,0.4277344 0.193359,1.0605469 z m -1.095703,-1.611328 v -1.822266 q -0.503906,0.0293 -1.189453,0.08789 -0.679687,0.05859 -1.078125,0.169922 -0.474609,0.134765 -0.767578,0.421875 -0.292969,0.28125 -0.292969,0.779297 0,0.5625 0.339844,0.849609 0.339844,0.28125 1.037109,0.28125 0.580078,0 1.060547,-0.222656 0.480469,-0.228516 0.890625,-0.544922 z" />
    <path
       id="path2243"
       style="stroke:none"
       d="m 48.597656,11.509766 q 0,0.509765 -0.240234,1.007812 -0.234375,0.498047 -0.66211,0.84375 -0.46875,0.375 -1.095703,0.585938 -0.621093,0.210937 -1.5,0.210937 -0.943359,0 -1.699218,-0.175781 -0.75,-0.175781 -1.529297,-0.521484 v -1.453125 h 0.08203 q 0.662109,0.550781 1.529297,0.849609 0.867187,0.298828 1.628906,0.298828 1.078125,0 1.675781,-0.404297 0.603516,-0.404297 0.603516,-1.078125 0,-0.580078 -0.287109,-0.855469 -0.28125,-0.27539 -0.861329,-0.427734 -0.439453,-0.117187 -0.955078,-0.193359 -0.509765,-0.07617 -1.083984,-0.19336 -1.160156,-0.2460935 -1.722656,-0.8378904 -0.556641,-0.5976562 -0.556641,-1.5527344 0,-1.0957031 0.925781,-1.7929687 0.925782,-0.703125 2.34961,-0.703125 0.919922,0 1.6875,0.1757812 0.767578,0.1757813 1.359375,0.4335938 v 1.3710937 h -0.08203 q -0.498046,-0.421875 -1.3125,-0.6972656 -0.808593,-0.28125 -1.658203,-0.28125 -0.93164,0 -1.5,0.3867188 -0.5625,0.3867187 -0.5625,0.9960937 0,0.5449219 0.28125,0.8554688 0.28125,0.3105469 0.990235,0.4746094 0.375,0.082031 1.066406,0.1992187 0.691406,0.1171875 1.171875,0.2402344 0.972656,0.2578125 1.464844,0.7792966 0.492187,0.521485 0.492186,1.458985 z" />
    <path
       id="path2245"
       style="stroke:none"
       d="m 59.923828,14 h -1.101562 v -3.726562 q 0,-0.4218755 -0.04102,-0.8144536 Q 58.746094,9.0664063 58.623047,8.8320313 58.488281,8.5800781 58.236328,8.4511719 57.984375,8.3222656 57.509766,8.3222656 q -0.462891,0 -0.925782,0.234375 -0.46289,0.2285157 -0.925781,0.5859375 0.01758,0.1347657 0.0293,0.3164063 0.01172,0.1757812 0.01172,0.3515625 V 14 H 54.59766 v -3.726562 q 0,-0.4335942 -0.04102,-0.820313 -0.03516,-0.3925781 -0.158204,-0.6269531 -0.134765,-0.2519531 -0.386718,-0.375 -0.251953,-0.1289063 -0.726563,-0.1289063 -0.451172,0 -0.908203,0.2226563 -0.451172,0.2226562 -0.902344,0.5683594 V 14 H 50.373047 V 7.4550781 h 1.101562 V 8.1816406 Q 51.990234,7.7539062 52.5,7.5136719 q 0.515625,-0.2402344 1.095703,-0.2402344 0.667969,0 1.130859,0.28125 0.46875,0.28125 0.697266,0.7792969 0.667969,-0.5625 1.21875,-0.8085938 0.550781,-0.2519531 1.177734,-0.2519531 1.078125,0 1.587891,0.65625 0.515625,0.6503906 0.515625,1.8222656 z" />
    <path
       id="path2247"
       style="stroke:none"
       d="M 63.228516,6.359375 H 61.986328 V 5.2167969 h 1.242188 z M 63.158203,14 H 62.056641 V 7.4550781 h 1.101562 z" />
    <path
       id="path2249"
       style="stroke:none"
       d="m 68.748047,13.941406 q -0.310547,0.08203 -0.679688,0.134766 -0.363281,0.05273 -0.65039,0.05273 -1.001953,0 -1.523438,-0.539062 -0.521484,-0.539063 -0.521484,-1.728516 V 8.3808594 H 64.628906 V 7.4550781 h 0.744141 V 5.5742187 h 1.101562 v 1.8808594 h 2.273438 v 0.9257813 h -2.273438 v 2.9824216 q 0,0.515625 0.02344,0.808594 0.02344,0.287109 0.164062,0.539063 0.128907,0.234375 0.351563,0.345703 0.228515,0.105468 0.691406,0.105468 0.269531,0 0.5625,-0.07617 0.292969,-0.08203 0.421875,-0.134766 h 0.05859 z" />
    <path
       id="path2251"
       style="stroke:none"
       d="m 75.556641,14 h -1.101563 v -3.726562 q 0,-0.4511724 -0.05273,-0.8437505 Q 74.349609,9.03125 74.208984,8.8085938 74.0625,8.5625 73.787109,8.4453125 73.511719,8.3222656 73.072266,8.3222656 q -0.451172,0 -0.94336,0.2226563 -0.492187,0.2226562 -0.943359,0.5683594 V 14 H 70.083984 V 4.8828125 h 1.101563 v 3.2988281 q 0.515625,-0.4277344 1.066406,-0.6679687 0.550781,-0.2402344 1.130859,-0.2402344 1.060547,0 1.617188,0.6386719 0.556641,0.6386719 0.556641,1.8398437 z" />
  </g>
  <path
     d="m 95,121.10131 h 5"
     style="font-size:12px;text-anchor:middle;stroke:#000000"
     id="line1290" />
  <path
     d="m 130.65168,129.91129 h 46.06708"
     style="font-size:12px;text-anchor:middle;stroke:#000000;stroke-width:1.51768;marker-end:url(#arrowtip_N)"
     id="line1294" />
  <path
     d="m 0,151.10131 h 90 v 20 H 0 Z"
     style="font-size:12px;text-anchor:middle;fill:#00ffff;stroke:none"
     id="use1298" />
  <g
     style="font-size:12px;text-anchor:middle;stroke:none"
     id="text1300"
     aria-label="Sam Doe"
     transform="translate(0,151.10131)">
    <path
       id="path2258"
       style="stroke:none"
       d="m 25.007812,11.509766 q 0,0.509765 -0.240234,1.007812 -0.234375,0.498047 -0.662109,0.84375 -0.46875,0.375 -1.095703,0.585938 -0.621094,0.210937 -1.5,0.210937 -0.94336,0 -1.699219,-0.175781 -0.75,-0.175781 -1.529297,-0.521484 v -1.453125 h 0.08203 q 0.66211,0.550781 1.529297,0.849609 0.867188,0.298828 1.628906,0.298828 1.078125,0 1.675782,-0.404297 0.603515,-0.404297 0.603515,-1.078125 0,-0.580078 -0.287109,-0.855469 -0.28125,-0.27539 -0.861328,-0.427734 -0.439453,-0.117187 -0.955078,-0.193359 -0.509766,-0.07617 -1.083985,-0.19336 -1.160156,-0.2460935 -1.722656,-0.8378904 -0.556641,-0.5976562 -0.556641,-1.5527344 0,-1.0957031 0.925782,-1.7929687 0.925781,-0.703125 2.349609,-0.703125 0.919922,0 1.6875,0.1757812 0.767578,0.1757813 1.359375,0.4335938 v 1.3710937 h -0.08203 q -0.498047,-0.421875 -1.3125,-0.6972656 -0.808594,-0.28125 -1.658203,-0.28125 -0.931641,0 -1.5,0.3867188 -0.5625,0.3867187 -0.5625,0.9960937 0,0.5449219 0.28125,0.8554688 0.28125,0.3105469 0.990234,0.4746094 0.375,0.082031 1.066406,0.1992187 0.691406,0.1171875 1.171875,0.2402344 0.972656,0.2578125 1.464844,0.7792966 0.492187,0.521485 0.492187,1.458985 z" />
    <path
       id="path2260"
       style="stroke:none"
       d="m 31.869141,14 h -1.095704 v -0.697266 q -0.146484,0.09961 -0.398437,0.28125 -0.246094,0.175782 -0.480469,0.28125 -0.27539,0.134766 -0.632812,0.222657 -0.357422,0.09375 -0.837891,0.09375 -0.884766,0 -1.5,-0.585938 -0.615234,-0.585937 -0.615234,-1.49414 0,-0.744141 0.316406,-1.201172 0.322266,-0.462891 0.914062,-0.726563 0.597657,-0.2636717 1.435547,-0.3574217 0.837891,-0.09375 1.798828,-0.140625 V 9.5058594 q 0,-0.375 -0.134765,-0.6210938 -0.128906,-0.2460937 -0.375,-0.3867187 -0.234375,-0.1347656 -0.5625,-0.1816406 -0.328125,-0.046875 -0.685547,-0.046875 -0.433594,0 -0.966797,0.1171875 -0.533203,0.1113281 -1.101562,0.328125 h -0.05859 V 7.5957031 q 0.322265,-0.087891 0.93164,-0.1933594 0.609375,-0.1054687 1.201172,-0.1054687 0.691407,0 1.201172,0.1171875 0.515625,0.1113281 0.890625,0.3867187 0.369141,0.2695313 0.5625,0.6972657 0.19336,0.4277344 0.19336,1.0605469 z m -1.095704,-1.611328 v -1.822266 q -0.503906,0.0293 -1.189453,0.08789 -0.679687,0.05859 -1.078125,0.169922 -0.474609,0.134765 -0.767578,0.421875 -0.292969,0.28125 -0.292969,0.779297 0,0.5625 0.339844,0.849609 0.339844,0.28125 1.03711,0.28125 0.580078,0 1.060546,-0.222656 0.480469,-0.228516 0.890625,-0.544922 z" />
    <path
       id="path2262"
       style="stroke:none"
       d="m 43.552734,14 h -1.101562 v -3.726562 q 0,-0.4218755 -0.04102,-0.8144536 Q 42.375,9.0664063 42.251953,8.8320313 42.117187,8.5800781 41.865234,8.4511719 41.613281,8.3222656 41.138672,8.3222656 q -0.462891,0 -0.925781,0.234375 -0.462891,0.2285157 -0.925782,0.5859375 0.01758,0.1347657 0.0293,0.3164063 0.01172,0.1757812 0.01172,0.3515625 V 14 h -1.101563 v -3.726562 q 0,-0.4335942 -0.04102,-0.820313 -0.03516,-0.3925781 -0.158203,-0.6269531 -0.134766,-0.2519531 -0.386719,-0.375 -0.251953,-0.1289063 -0.726563,-0.1289063 -0.451171,0 -0.908203,0.2226563 -0.451172,0.2226562 -0.902343,0.5683594 V 14 H 34.001953 V 7.4550781 h 1.101563 v 0.7265625 q 0.515625,-0.4277344 1.02539,-0.6679687 0.515625,-0.2402344 1.095703,-0.2402344 0.667969,0 1.13086,0.28125 0.46875,0.28125 0.697265,0.7792969 0.667969,-0.5625 1.21875,-0.8085938 0.550782,-0.2519531 1.177735,-0.2519531 1.078125,0 1.58789,0.65625 0.515625,0.6503906 0.515625,1.8222656 z" />
    <path
       id="path2264"
       style="stroke:none"
       d="m 57.351562,9.6464844 q 0,1.1894536 -0.521484,2.1562496 -0.515625,0.966797 -1.376953,1.5 -0.597656,0.369141 -1.335938,0.533204 Q 53.384766,14 52.183594,14 H 49.980469 V 5.2753906 h 2.179687 q 1.277344,0 2.027344,0.1875 0.755859,0.1816406 1.277344,0.5039063 0.890625,0.5566406 1.388672,1.4824218 0.498046,0.9257813 0.498046,2.1972657 z m -1.21289,-0.017578 q 0,-1.0253907 -0.357422,-1.7285157 Q 55.423828,7.1972656 54.714844,6.7929687 54.199219,6.5 53.619141,6.3886719 53.039062,6.2714844 52.230469,6.2714844 h -1.089844 v 6.7324216 h 1.089844 q 0.83789,0 1.458984,-0.123047 0.626953,-0.123046 1.148438,-0.457031 0.65039,-0.416015 0.972656,-1.095703 0.328125,-0.679687 0.328125,-1.6992186 z" />
    <path
       id="path2266"
       style="stroke:none"
       d="m 64.728516,10.730469 q 0,1.599609 -0.820313,2.52539 -0.820312,0.925782 -2.197266,0.925782 -1.388671,0 -2.208984,-0.925782 -0.814453,-0.925781 -0.814453,-2.52539 0,-1.5996096 0.814453,-2.5253909 0.820313,-0.9316406 2.208984,-0.9316406 1.376954,0 2.197266,0.9316406 0.820313,0.9257813 0.820313,2.5253909 z m -1.136719,0 q 0,-1.2714846 -0.498047,-1.886719 -0.498047,-0.6210937 -1.382813,-0.6210937 -0.896484,0 -1.394531,0.6210937 -0.492187,0.6152344 -0.492187,1.886719 0,1.230469 0.498047,1.86914 0.498046,0.632813 1.388671,0.632813 0.878907,0 1.376954,-0.626953 0.503906,-0.632813 0.503906,-1.875 z" />
    <path
       id="path2268"
       style="stroke:none"
       d="m 71.917969,10.841797 h -4.822266 q 0,0.603516 0.181641,1.054687 0.18164,0.445313 0.498047,0.732422 0.304687,0.28125 0.720703,0.421875 0.421875,0.140625 0.925781,0.140625 0.667969,0 1.341797,-0.263672 0.679687,-0.269531 0.966797,-0.527343 h 0.05859 v 1.201172 q -0.55664,0.234375 -1.136718,0.392578 -0.580078,0.158203 -1.21875,0.158203 -1.628907,0 -2.542969,-0.878906 -0.914063,-0.884766 -0.914063,-2.507813 0,-1.6054687 0.873047,-2.5488281 0.878907,-0.9433594 2.308594,-0.9433594 1.324219,0 2.039063,0.7734375 0.720703,0.7734375 0.720703,2.197266 z M 70.845703,9.9980469 Q 70.839844,9.1308594 70.40625,8.65625 69.978516,8.1816406 69.099609,8.1816406 q -0.884765,0 -1.412109,0.5214844 -0.521484,0.5214844 -0.591797,1.2949219 z" />
  </g>
  <path
     d="m 95,161.10131 h 5"
     style="font-size:12px;text-anchor:middle;stroke:#000000"
     id="line1302" />
  <path
     d="m 130.63751,189.91129 h 45.50041"
     style="font-size:12px;text-anchor:middle;stroke:#000000;stroke-width:1.50832;marker-end:url(#arrowtip_N)"
     id="line1306" />
  <path
     d="m 0,191.10131 h 90 v 20 H 0 Z"
     style="font-size:12px;text-anchor:middle;fill:#00ffff;stroke:none"
     id="use1310" />
  <g
     style="font-size:12px;text-anchor:middle;stroke:none"
     id="text1312"
     aria-label="Sandra Dee"
     transform="translate(0,191.10131)">
    <path
       id="path2275"
       style="stroke:none"
       d="m 17.203125,11.509766 q 0,0.509765 -0.240234,1.007812 -0.234375,0.498047 -0.66211,0.84375 -0.46875,0.375 -1.095703,0.585938 -0.621094,0.210937 -1.5,0.210937 -0.943359,0 -1.699219,-0.175781 -0.75,-0.175781 -1.529296,-0.521484 v -1.453125 h 0.08203 q 0.662109,0.550781 1.529297,0.849609 0.867187,0.298828 1.628906,0.298828 1.078125,0 1.675781,-0.404297 0.603516,-0.404297 0.603516,-1.078125 0,-0.580078 -0.28711,-0.855469 -0.28125,-0.27539 -0.861328,-0.427734 -0.439453,-0.117187 -0.955078,-0.193359 -0.509765,-0.07617 -1.083984,-0.19336 -1.160156,-0.2460935 -1.722656,-0.8378904 -0.556641,-0.5976562 -0.556641,-1.5527344 0,-1.0957031 0.925781,-1.7929687 0.925781,-0.703125 2.34961,-0.703125 0.919921,0 1.6875,0.1757812 0.767578,0.1757813 1.359374,0.4335938 v 1.3710937 h -0.08203 q -0.498047,-0.421875 -1.3125,-0.6972656 -0.808593,-0.28125 -1.658203,-0.28125 -0.93164,0 -1.5,0.3867188 -0.5625,0.3867187 -0.5625,0.9960937 0,0.5449219 0.28125,0.8554688 0.28125,0.3105469 0.990235,0.4746094 0.375,0.082031 1.066406,0.1992187 0.691406,0.1171875 1.171875,0.2402344 0.972656,0.2578125 1.464843,0.7792966 0.492188,0.521485 0.492188,1.458985 z" />
    <path
       id="path2277"
       style="stroke:none"
       d="M 24.064453,14 H 22.96875 v -0.697266 q -0.146484,0.09961 -0.398438,0.28125 -0.246093,0.175782 -0.480468,0.28125 Q 21.814453,14 21.457031,14.087891 q -0.357422,0.09375 -0.83789,0.09375 -0.884766,0 -1.5,-0.585938 -0.615235,-0.585937 -0.615235,-1.49414 0,-0.744141 0.316406,-1.201172 0.322266,-0.462891 0.914063,-0.726563 0.597656,-0.2636717 1.435547,-0.3574217 0.83789,-0.09375 1.798828,-0.140625 V 9.5058594 q 0,-0.375 -0.134766,-0.6210938 -0.128906,-0.2460937 -0.375,-0.3867187 -0.234375,-0.1347656 -0.5625,-0.1816406 -0.328125,-0.046875 -0.685547,-0.046875 -0.433593,0 -0.966796,0.1171875 -0.533204,0.1113281 -1.101563,0.328125 h -0.05859 V 7.5957031 Q 19.40625,7.5078125 20.015625,7.4023437 20.625,7.296875 21.216797,7.296875 q 0.691406,0 1.201172,0.1171875 0.515625,0.1113281 0.890625,0.3867187 0.36914,0.2695313 0.5625,0.6972657 0.193359,0.4277344 0.193359,1.0605469 z M 22.96875,12.388672 v -1.822266 q -0.503906,0.0293 -1.189453,0.08789 -0.679688,0.05859 -1.078125,0.169922 -0.47461,0.134765 -0.767578,0.421875 -0.292969,0.28125 -0.292969,0.779297 0,0.5625 0.339844,0.849609 0.339843,0.28125 1.037109,0.28125 0.580078,0 1.060547,-0.222656 0.480469,-0.228516 0.890625,-0.544922 z" />
    <path
       id="path2279"
       style="stroke:none"
       d="m 31.669922,14 h -1.101563 v -3.726562 q 0,-0.4511724 -0.05273,-0.8437505 Q 30.462891,9.03125 30.322266,8.8085938 30.175781,8.5625 29.900391,8.4453125 29.625,8.3222656 29.185547,8.3222656 q -0.451172,0 -0.94336,0.2226563 Q 27.75,8.7675781 27.298828,9.1132813 V 14 H 26.197266 V 7.4550781 h 1.101562 v 0.7265625 q 0.515625,-0.4277344 1.066406,-0.6679687 0.550782,-0.2402344 1.13086,-0.2402344 1.060547,0 1.617187,0.6386719 0.556641,0.6386719 0.556641,1.8398437 z" />
    <path
       id="path2281"
       style="stroke:none"
       d="m 39.099609,14 h -1.101562 v -0.685547 q -0.47461,0.410156 -0.990235,0.638672 -0.515625,0.228516 -1.11914,0.228516 -1.171875,0 -1.863281,-0.902344 -0.685547,-0.902344 -0.685547,-2.501953 0,-0.8320315 0.234375,-1.4824221 0.240234,-0.6503906 0.644531,-1.1074219 0.398437,-0.4453125 0.925781,-0.6796875 0.533203,-0.234375 1.101563,-0.234375 0.515625,0 0.914062,0.1113281 0.398438,0.1054688 0.837891,0.3339844 V 4.8828125 h 1.101562 z M 37.998047,12.388672 V 8.6328125 Q 37.552734,8.4335938 37.201172,8.3574219 36.849609,8.28125 36.433594,8.28125 q -0.925782,0 -1.441407,0.6445313 -0.515625,0.6445312 -0.515625,1.8281247 0,1.166016 0.398438,1.775391 0.398437,0.603516 1.277344,0.603516 0.46875,0 0.949218,-0.205079 0.480469,-0.210937 0.896485,-0.539062 z" />
    <path
       id="path2283"
       style="stroke:none"
       d="m 45.351562,8.65625 h -0.05859 Q 45.046878,8.597656 44.812503,8.574219 44.583987,8.544922 44.267581,8.544922 q -0.509766,0 -0.984375,0.2285156 -0.474609,0.2226563 -0.914062,0.5800781 V 14 H 41.267578 V 7.4550781 h 1.101563 V 8.421875 q 0.65625,-0.5273438 1.154296,-0.7441406 0.503907,-0.2226563 1.025391,-0.2226563 0.287109,0 0.416016,0.017578 0.128906,0.011719 0.386718,0.052734 z" />
    <path
       id="path2285"
       style="stroke:none"
       d="m 51.486328,14 h -1.095703 v -0.697266 q -0.146484,0.09961 -0.398438,0.28125 -0.246093,0.175782 -0.480468,0.28125 Q 49.236328,14 48.878906,14.087891 q -0.357422,0.09375 -0.83789,0.09375 -0.884766,0 -1.5,-0.585938 -0.615235,-0.585937 -0.615235,-1.49414 0,-0.744141 0.316406,-1.201172 0.322266,-0.462891 0.914063,-0.726563 0.597656,-0.2636717 1.435547,-0.3574217 0.83789,-0.09375 1.798828,-0.140625 V 9.5058594 q 0,-0.375 -0.134766,-0.6210938 -0.128906,-0.2460937 -0.375,-0.3867187 -0.234375,-0.1347656 -0.5625,-0.1816406 -0.328125,-0.046875 -0.685547,-0.046875 -0.433593,0 -0.966796,0.1171875 -0.533204,0.1113281 -1.101563,0.328125 h -0.05859 V 7.5957031 Q 46.828125,7.5078125 47.4375,7.4023437 48.046875,7.296875 48.638672,7.296875 q 0.691406,0 1.201172,0.1171875 0.515625,0.1113281 0.890625,0.3867187 0.36914,0.2695313 0.5625,0.6972657 0.193359,0.4277344 0.193359,1.0605469 z m -1.095703,-1.611328 v -1.822266 q -0.503906,0.0293 -1.189453,0.08789 -0.679688,0.05859 -1.078125,0.169922 -0.47461,0.134765 -0.767578,0.421875 -0.292969,0.28125 -0.292969,0.779297 0,0.5625 0.339844,0.849609 0.339843,0.28125 1.037109,0.28125 0.580078,0 1.060547,-0.222656 0.480469,-0.228516 0.890625,-0.544922 z" />
    <path
       id="path2287"
       style="stroke:none"
       d="m 65.296875,9.6464844 q 0,1.1894536 -0.521484,2.1562496 -0.515625,0.966797 -1.376954,1.5 Q 62.800781,13.671875 62.0625,13.835938 61.330078,14 60.128906,14 H 57.925781 V 5.2753906 h 2.179688 q 1.277343,0 2.027343,0.1875 0.75586,0.1816406 1.277344,0.5039063 0.890625,0.5566406 1.388672,1.4824218 0.498047,0.9257813 0.498047,2.1972657 z m -1.212891,-0.017578 q 0,-1.0253907 -0.357422,-1.7285157 Q 63.369141,7.1972656 62.660156,6.7929687 62.144531,6.5 61.564453,6.3886719 60.984375,6.2714844 60.175781,6.2714844 h -1.089844 v 6.7324216 h 1.089844 q 0.837891,0 1.458985,-0.123047 0.626953,-0.123046 1.148437,-0.457031 0.650391,-0.416015 0.972656,-1.095703 0.328125,-0.679687 0.328125,-1.6992186 z" />
    <path
       id="path2289"
       style="stroke:none"
       d="m 72.574219,10.841797 h -4.822266 q 0,0.603516 0.181641,1.054687 0.18164,0.445313 0.498047,0.732422 0.304687,0.28125 0.720703,0.421875 0.421875,0.140625 0.925781,0.140625 0.667969,0 1.341797,-0.263672 0.679687,-0.269531 0.966797,-0.527343 h 0.05859 v 1.201172 q -0.55664,0.234375 -1.136718,0.392578 -0.580078,0.158203 -1.21875,0.158203 -1.628907,0 -2.542969,-0.878906 -0.914063,-0.884766 -0.914063,-2.507813 0,-1.6054687 0.873047,-2.5488281 0.878907,-0.9433594 2.308594,-0.9433594 1.324219,0 2.039063,0.7734375 0.720703,0.7734375 0.720703,2.197266 z M 71.501953,9.9980469 Q 71.496094,9.1308594 71.0625,8.65625 70.634766,8.1816406 69.755859,8.1816406 q -0.884765,0 -1.412109,0.5214844 -0.521484,0.5214844 -0.591797,1.2949219 z" />
    <path
       id="path2291"
       style="stroke:none"
       d="m 79.722656,10.841797 h -4.822265 q 0,0.603516 0.18164,1.054687 0.181641,0.445313 0.498047,0.732422 0.304688,0.28125 0.720703,0.421875 0.421875,0.140625 0.925781,0.140625 0.667969,0 1.341797,-0.263672 0.679688,-0.269531 0.966797,-0.527343 h 0.05859 v 1.201172 q -0.556641,0.234375 -1.136719,0.392578 -0.580078,0.158203 -1.21875,0.158203 -1.628906,0 -2.542969,-0.878906 -0.914062,-0.884766 -0.914062,-2.507813 0,-1.6054687 0.873047,-2.5488281 0.878906,-0.9433594 2.308594,-0.9433594 1.324218,0 2.039062,0.7734375 0.720703,0.7734375 0.720703,2.197266 z M 78.650391,9.9980469 Q 78.644531,9.1308594 78.210937,8.65625 77.783203,8.1816406 76.904297,8.1816406 q -0.884766,0 -1.41211,0.5214844 -0.521484,0.5214844 -0.591796,1.2949219 z" />
  </g>
  <path
     d="m 95,201.10131 h 5"
     style="font-size:12px;text-anchor:middle;stroke:#dd0000"
     id="line1314" />
  <path
     d="m 100,201.10131 30,-50"
     style="font-size:12px;text-anchor:middle;stroke:#dd0000"
     id="line1316" />
  <path
     d="m 0,231.10131 h 90 v 20 H 0 Z"
     style="font-size:12px;text-anchor:middle;fill:#00ffff;stroke:none"
     id="use1322" />
  <g
     style="font-size:12px;text-anchor:middle;stroke:none"
     id="text1324"
     aria-label="Ted Baker"
     transform="translate(0,231.10131)">
    <path
       id="path2298"
       style="stroke:none"
       d="M 21.855469,6.3066406 H 18.738281 V 14 H 17.578125 V 6.3066406 h -3.117187 v -1.03125 h 7.394531 z" />
    <path
       id="path2300"
       style="stroke:none"
       d="m 28.429687,10.841797 h -4.822265 q 0,0.603516 0.18164,1.054687 0.181641,0.445313 0.498047,0.732422 0.304688,0.28125 0.720703,0.421875 0.421875,0.140625 0.925782,0.140625 0.667968,0 1.341797,-0.263672 0.679687,-0.269531 0.966796,-0.527343 h 0.05859 v 1.201172 q -0.55664,0.234375 -1.136719,0.392578 -0.580078,0.158203 -1.21875,0.158203 -1.628906,0 -2.542968,-0.878906 -0.914063,-0.884766 -0.914063,-2.507813 0,-1.6054687 0.873047,-2.5488281 0.878906,-0.9433594 2.308594,-0.9433594 1.324219,0 2.039062,0.7734375 0.720703,0.7734375 0.720703,2.197266 z M 27.357422,9.9980469 Q 27.351562,9.1308594 26.917969,8.65625 26.490234,8.1816406 25.611328,8.1816406 q -0.884766,0 -1.412109,0.5214844 -0.521485,0.5214844 -0.591797,1.2949219 z" />
    <path
       id="path2302"
       style="stroke:none"
       d="m 35.408203,14 h -1.101562 v -0.685547 q -0.47461,0.410156 -0.990235,0.638672 -0.515625,0.228516 -1.11914,0.228516 -1.171875,0 -1.863282,-0.902344 -0.685547,-0.902344 -0.685547,-2.501953 0,-0.8320315 0.234375,-1.4824221 0.240235,-0.6503906 0.644532,-1.1074219 0.398437,-0.4453125 0.925781,-0.6796875 0.533203,-0.234375 1.101562,-0.234375 0.515625,0 0.914063,0.1113281 0.398437,0.1054688 0.837891,0.3339844 V 4.8828125 h 1.101562 z M 34.306641,12.388672 V 8.6328125 Q 33.861328,8.4335938 33.509766,8.3574219 33.158203,8.28125 32.742187,8.28125 q -0.925781,0 -1.441406,0.6445313 -0.515625,0.6445312 -0.515625,1.8281247 0,1.166016 0.398438,1.775391 0.398437,0.603516 1.277343,0.603516 0.46875,0 0.949219,-0.205079 0.480469,-0.210937 0.896485,-0.539062 z" />
    <path
       id="path2304"
       style="stroke:none"
       d="m 48.462891,11.316406 q 0,0.650391 -0.246094,1.148438 -0.246094,0.498047 -0.66211,0.820312 Q 47.0625,13.671875 46.470703,13.835938 45.884766,14 44.976562,14 h -3.09375 V 5.2753906 h 2.583985 q 0.955078,0 1.429687,0.070312 0.47461,0.070312 0.908203,0.2929688 0.480469,0.2519531 0.697266,0.6503906 0.216797,0.3925781 0.216797,0.9433594 0,0.6210937 -0.316406,1.0605469 -0.316407,0.4335937 -0.84375,0.6972656 v 0.046875 q 0.884765,0.1816406 1.394531,0.7792969 0.509766,0.5917972 0.509766,1.5000002 z M 46.511719,7.3847656 q 0,-0.3164062 -0.105469,-0.5332031 Q 46.300781,6.6347656 46.066406,6.5 45.791016,6.3417969 45.398437,6.3066406 45.005859,6.265625 44.425781,6.265625 h -1.382812 v 2.5195313 h 1.5 q 0.544922,0 0.867187,-0.052734 0.322266,-0.058594 0.597656,-0.234375 0.275391,-0.1757813 0.386719,-0.4511719 0.117188,-0.28125 0.117188,-0.6621098 z m 0.74414,3.9785154 q 0,-0.527343 -0.158203,-0.83789 -0.158203,-0.310547 -0.574219,-0.5273441 -0.28125,-0.1464844 -0.685546,-0.1875 -0.398438,-0.046875 -0.972657,-0.046875 h -1.822265 v 3.2460941 h 1.535156 q 0.761719,0 1.248047,-0.07617 0.486328,-0.08203 0.796875,-0.292969 0.328125,-0.228516 0.480469,-0.521484 0.152343,-0.292969 0.152343,-0.75586 z" />
    <path
       id="path2306"
       style="stroke:none"
       d="m 55.107422,14 h -1.095703 v -0.697266 q -0.146485,0.09961 -0.398438,0.28125 -0.246094,0.175782 -0.480469,0.28125 Q 52.857422,14 52.5,14.087891 q -0.357422,0.09375 -0.837891,0.09375 -0.884765,0 -1.5,-0.585938 -0.615234,-0.585937 -0.615234,-1.49414 0,-0.744141 0.316406,-1.201172 0.322266,-0.462891 0.914063,-0.726563 0.597656,-0.2636717 1.435547,-0.3574217 0.83789,-0.09375 1.798828,-0.140625 V 9.5058594 q 0,-0.375 -0.134766,-0.6210938 -0.128906,-0.2460937 -0.375,-0.3867187 -0.234375,-0.1347656 -0.5625,-0.1816406 -0.328125,-0.046875 -0.685547,-0.046875 -0.433594,0 -0.966797,0.1171875 -0.533203,0.1113281 -1.101562,0.328125 h -0.05859 V 7.5957031 q 0.322266,-0.087891 0.931641,-0.1933594 0.609375,-0.1054687 1.201172,-0.1054687 0.691406,0 1.201171,0.1171875 0.515625,0.1113281 0.890625,0.3867187 0.369141,0.2695313 0.5625,0.6972657 0.19336,0.4277344 0.19336,1.0605469 z m -1.095703,-1.611328 v -1.822266 q -0.503907,0.0293 -1.189453,0.08789 -0.679688,0.05859 -1.078125,0.169922 -0.47461,0.134765 -0.767579,0.421875 -0.292968,0.28125 -0.292968,0.779297 0,0.5625 0.339843,0.849609 0.339844,0.28125 1.03711,0.28125 0.580078,0 1.060547,-0.222656 0.480468,-0.228516 0.890625,-0.544922 z" />
    <path
       id="path2308"
       style="stroke:none"
       d="m 63.181641,14 h -1.453125 l -2.625,-2.865234 -0.714844,0.679687 V 14 H 57.287109 V 4.8828125 h 1.101563 v 5.8476565 l 3.18164,-3.2753909 h 1.388672 l -3.041015,3.0234379 z" />
    <path
       id="path2310"
       style="stroke:none"
       d="m 69.820312,10.841797 h -4.822265 q 0,0.603516 0.18164,1.054687 0.181641,0.445313 0.498047,0.732422 0.304688,0.28125 0.720703,0.421875 0.421875,0.140625 0.925782,0.140625 0.667968,0 1.341797,-0.263672 0.679687,-0.269531 0.966796,-0.527343 h 0.05859 v 1.201172 q -0.55664,0.234375 -1.136719,0.392578 -0.580078,0.158203 -1.21875,0.158203 -1.628906,0 -2.542968,-0.878906 -0.914063,-0.884766 -0.914063,-2.507813 0,-1.6054687 0.873047,-2.5488281 0.878906,-0.9433594 2.308594,-0.9433594 1.324219,0 2.039062,0.7734375 0.720703,0.7734375 0.720703,2.197266 z M 68.748047,9.9980469 Q 68.742187,9.1308594 68.308594,8.65625 67.880859,8.1816406 67.001953,8.1816406 q -0.884766,0 -1.412109,0.5214844 -0.521485,0.5214844 -0.591797,1.2949219 z" />
    <path
       id="path2312"
       style="stroke:none"
       d="m 75.574219,8.65625 h -0.05859 Q 75.269535,8.597656 75.03516,8.574219 74.806645,8.544922 74.490238,8.544922 q -0.509765,0 -0.984375,0.2285156 -0.474609,0.2226563 -0.914062,0.5800781 V 14 H 71.490234 V 7.4550781 h 1.101563 V 8.421875 q 0.65625,-0.5273438 1.154297,-0.7441406 0.503906,-0.2226563 1.02539,-0.2226563 0.28711,0 0.416016,0.017578 0.128906,0.011719 0.386719,0.052734 z" />
  </g>
  <path
     d="m 95,241.10131 h 5"
     style="font-size:12px;text-anchor:middle;stroke:#000000"
     id="line1326" />
  <path
     d="m 100,241.10131 30,-70"
     style="font-size:12px;text-anchor:middle;stroke:#000000"
     id="line1328" />
  <path
     d="m 130.62334,171.10131 h 44.93374"
     style="font-size:12px;text-anchor:middle;stroke:#000000;stroke-width:1.4989;marker-end:url(#arrowtip_N)"
     id="line1330" />
  <g
     aria-label="buckets"
     id="text1336"
     style="font-weight:bold;font-size:15px;text-anchor:middle;fill:#000000;stroke:none"
     transform="translate(179.75048,39.911294)">
    <path
       d="m 111.94336,-14.226074 q 0,1.940918 -1.07666,3.164062 -1.06934,1.2231448 -2.67334,1.2231448 -0.68848,0 -1.2085,-0.1464844 -0.52002,-0.1464844 -0.98877,-0.4248044 L 105.88623,-10 h -2.52685 v -11.396484 h 2.63671 v 4.02832 q 0.60791,-0.483398 1.2378,-0.783691 0.6372,-0.300293 1.46484,-0.300293 1.56006,0 2.40234,1.127929 0.84229,1.120606 0.84229,3.098145 z m -2.71729,0.05127 q 0,-1.098633 -0.37353,-1.691894 -0.37354,-0.593262 -1.33301,-0.593262 -0.37353,0 -0.76904,0.117188 -0.39551,0.109863 -0.7544,0.322265 v 4.13086 q 0.28565,0.102539 0.542,0.13916 0.25634,0.03662 0.61523,0.03662 1.04736,0 1.56006,-0.615235 0.51269,-0.615234 0.51269,-1.845702 z"
       style="font-weight:bold;font-size:15px;fill:#000000;stroke:none"
       id="path2318" />
    <path
       d="m 122.04346,-10 h -2.63672 v -0.908203 q -0.73242,0.55664 -1.34033,0.849609 -0.60791,0.2856448 -1.4502,0.2856448 -1.3623,0 -2.10205,-0.7836918 -0.73242,-0.783691 -0.73242,-2.314453 v -5.354004 h 2.65137 v 4.07959 q 0,0.622559 0.0366,1.040039 0.0439,0.410156 0.19043,0.681153 0.13916,0.270996 0.41748,0.395507 0.28564,0.124512 0.79101,0.124512 0.33692,0 0.74707,-0.124512 0.41016,-0.124511 0.79102,-0.366211 v -5.830078 h 2.63672 z"
       style="font-weight:bold;font-size:15px;fill:#000000;stroke:none"
       id="path2320" />
    <path
       d="m 128.82568,-9.7802734 q -1.07666,0 -1.97021,-0.2563476 -0.88623,-0.256348 -1.54541,-0.791016 -0.65186,-0.534668 -1.01074,-1.347656 -0.35889,-0.812988 -0.35889,-1.904297 0,-1.149902 0.38086,-1.984863 0.38818,-0.834961 1.07666,-1.384277 0.6665,-0.52002 1.53809,-0.761719 0.87158,-0.241699 1.80908,-0.241699 0.84228,0 1.55273,0.183105 0.71045,0.183106 1.32569,0.476074 v 2.248535 H 131.25 q -0.15381,-0.131836 -0.37354,-0.307617 -0.2124,-0.175781 -0.52734,-0.344238 -0.30029,-0.161133 -0.65918,-0.263672 -0.35889,-0.109863 -0.83496,-0.109863 -1.05469,0 -1.62598,0.673828 -0.56396,0.666504 -0.56396,1.816406 0,1.186524 0.57861,1.801758 0.58594,0.615234 1.65528,0.615234 0.49804,0 0.89355,-0.109863 0.40283,-0.117187 0.6665,-0.270996 0.24903,-0.146484 0.43946,-0.307617 0.19043,-0.161133 0.35156,-0.314942 h 0.37354 v 2.248536 q -0.62256,0.292968 -1.30372,0.4614253 -0.67382,0.1757813 -1.49414,0.1757813 z"
       style="font-weight:bold;font-size:15px;fill:#000000;stroke:none"
       id="path2322" />
    <path
       d="M 142.08984,-10 H 139.021 l -2.30713,-3.581543 -0.71778,0.871582 V -10 h -2.63672 v -11.396484 h 2.63672 v 6.804199 l 2.8418,-3.632813 h 3.03955 l -2.95898,3.544922 z"
       style="font-weight:bold;font-size:15px;fill:#000000;stroke:none"
       id="path2324" />
    <path
       d="m 151.53809,-13.625488 h -6.03516 q 0.0586,0.966797 0.73242,1.479492 0.68115,0.512695 1.99951,0.512695 0.83496,0 1.61866,-0.300293 0.78369,-0.300293 1.23779,-0.644531 h 0.29297 v 2.116699 q -0.89356,0.358887 -1.68457,0.5200197 -0.79102,0.1611329 -1.75049,0.1611329 -2.47559,0 -3.79395,-1.1132816 -1.31836,-1.113281 -1.31836,-3.171386 0,-2.036133 1.24512,-3.222657 1.25244,-1.193847 3.42774,-1.193847 2.00683,0 3.01757,1.018066 1.01075,1.010742 1.01075,2.915039 z m -2.62207,-1.54541 q -0.022,-0.827637 -0.41016,-1.245118 -0.38818,-0.41748 -1.2085,-0.41748 -0.76172,0 -1.25244,0.395508 -0.49072,0.395508 -0.54931,1.26709 z"
       style="font-weight:bold;font-size:15px;fill:#000000;stroke:none"
       id="path2326" />
    <path
       d="m 158.65723,-10.073242 q -0.42481,0.1098631 -0.90088,0.1684568 -0.47608,0.065918 -1.16455,0.065918 -1.53809,0 -2.29248,-0.6225588 -0.74707,-0.622558 -0.74707,-2.131347 v -3.845215 h -1.08399 v -1.78711 h 1.08399 v -2.351074 h 2.63671 v 2.351074 h 2.46827 v 1.78711 h -2.46827 v 2.915039 q 0,0.432129 0.007,0.754394 0.007,0.322266 0.11719,0.578614 0.10254,0.256347 0.35888,0.410156 0.26368,0.146484 0.76172,0.146484 0.20508,0 0.53467,-0.08789 0.33691,-0.08789 0.46875,-0.161133 h 0.21973 z"
       style="font-weight:bold;font-size:15px;fill:#000000;stroke:none"
       id="path2328" />
    <path
       d="m 167.37305,-12.607422 q 0,1.274414 -1.14258,2.058106 -1.14258,0.7763668 -3.12744,0.7763668 -1.09864,0 -1.99219,-0.2050781 -0.89355,-0.2050777 -1.43555,-0.4541017 v -2.167969 h 0.2417 q 0.19776,0.13916 0.4541,0.307618 0.26368,0.161132 0.73975,0.351562 0.41016,0.168457 0.93018,0.292969 0.52002,0.117187 1.11328,0.117187 0.77636,0 1.1499,-0.168457 0.37353,-0.175781 0.37353,-0.512695 0,-0.300293 -0.21972,-0.432129 -0.21973,-0.13916 -0.83496,-0.263672 -0.29297,-0.06592 -0.79834,-0.13916 -0.49805,-0.08057 -0.90821,-0.19043 -1.1206,-0.292968 -1.66259,-0.908203 -0.542,-0.622558 -0.542,-1.54541 0,-1.186523 1.12061,-1.970215 1.12793,-0.791015 3.07617,-0.791015 0.92285,0 1.76514,0.190429 0.84961,0.183106 1.32568,0.395508 v 2.080078 h -0.22705 q -0.58594,-0.402832 -1.34033,-0.651855 -0.74707,-0.256348 -1.51611,-0.256348 -0.63721,0 -1.07666,0.175781 -0.43213,0.175782 -0.43213,0.498047 0,0.292969 0.19775,0.446778 0.19775,0.153808 0.93018,0.307617 0.40283,0.08057 0.86425,0.161133 0.46875,0.07324 0.9375,0.190429 1.04004,0.270996 1.53809,0.856934 0.49805,0.578613 0.49805,1.450195 z"
       style="font-weight:bold;font-size:15px;fill:#000000;stroke:none"
       id="path2330" />
  </g>
  <path
     d="m 182.75048,100.91129 h 34 v 18 h -34 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;stroke:none"
     id="use1338" />
  <path
     d="m 210.40868,109.54606 q 0,2.34961 -0.73828,3.45117 -0.73242,1.0957 -2.2793,1.0957 -1.57031,0 -2.29687,-1.11328 -0.7207,-1.11328 -0.7207,-3.42187 0,-2.32617 0.73242,-3.4336 0.73242,-1.11328 2.28515,-1.11328 1.57032,0 2.29102,1.13086 0.72656,1.125 0.72656,3.4043 z m -1.54101,2.66016 q 0.20508,-0.47461 0.27539,-1.11329 0.0762,-0.64453 0.0762,-1.54687 0,-0.89063 -0.0762,-1.54688 -0.0703,-0.65625 -0.28125,-1.11328 -0.20508,-0.45117 -0.5625,-0.67968 -0.35156,-0.22852 -0.90821,-0.22852 -0.55078,0 -0.91406,0.22852 -0.35742,0.22851 -0.56836,0.6914 -0.19922,0.4336 -0.27539,1.13086 -0.0703,0.69727 -0.0703,1.5293 0,0.91406 0.0644,1.5293 0.0644,0.61523 0.27539,1.10156 0.19336,0.45703 0.54492,0.69726 0.35743,0.24024 0.94336,0.24024 0.55079,0 0.91407,-0.22852 0.36328,-0.22851 0.5625,-0.6914 z"
     id="path2338"
     style="font-size:12px;text-anchor:middle;stroke:none" />
  <path
     d="m 219.75048,99.911294 h 90 v 19.999996 h -90 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;stroke:#000000"
     id="use1342" />
  <path
     d="m 309.75048,99.911294 h 80 v 19.999996 h -80 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;stroke:#000000"
     id="use1344" />
  <path
     d="m 389.75048,99.911294 h 20 v 19.999996 h -20 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;stroke:#000000"
     id="use1346" />
  <path
     d="m 399.75048,109.91129 h 0.001"
     style="font-size:12px;text-anchor:middle;stroke:#000000;marker-start:url(#linkdot_U)"
     id="line1348" />
  <path
     d="m 182.75048,160.91129 h 34 v 18 h -34 z"
     style="font-size:12px;text-anchor:middle;fill:#a8a8ff;stroke:none"
     id="use1426" />
  <path
     d="m 209.65282,169.71012 q 0.28125,0.25195 0.46289,0.63281 0.18164,0.38086 0.18164,0.98438 0,0.59765 -0.21679,1.0957 -0.2168,0.49805 -0.60938,0.86719 -0.43945,0.41015 -1.03711,0.60937 -0.59179,0.19336 -1.30078,0.19336 -0.72656,0 -1.42969,-0.17578 -0.70312,-0.16992 -1.15429,-0.375 v -1.22461 h 0.0879 q 0.49804,0.32812 1.17187,0.54492 0.67383,0.2168 1.30078,0.2168 0.36914,0 0.78516,-0.12305 0.41602,-0.12305 0.67383,-0.36328 0.26953,-0.25781 0.39844,-0.56836 0.13476,-0.31055 0.13476,-0.78516 0,-0.46875 -0.15234,-0.77343 -0.14649,-0.31055 -0.41016,-0.48633 -0.26367,-0.18164 -0.63867,-0.24609 -0.375,-0.0703 -0.80859,-0.0703 h -0.52735 v -0.97265 h 0.41016 q 0.89062,0 1.41797,-0.36914 0.5332,-0.375 0.5332,-1.08985 0,-0.3164 -0.13476,-0.55078 -0.13477,-0.24023 -0.375,-0.39258 -0.25196,-0.15234 -0.53907,-0.21093 -0.28711,-0.0586 -0.65039,-0.0586 -0.55664,0 -1.18359,0.19922 -0.62695,0.19922 -1.1836,0.5625 h -0.0586 v -1.22461 q 0.41602,-0.20508 1.10743,-0.375 0.69726,-0.17578 1.34765,-0.17578 0.63867,0 1.125,0.11719 0.48633,0.11718 0.87891,0.375 0.42188,0.28125 0.63867,0.67968 0.2168,0.39844 0.2168,0.93165 0,0.72656 -0.51563,1.27148 -0.50976,0.53906 -1.20703,0.67969 v 0.082 q 0.28125,0.0469 0.64453,0.19922 0.36329,0.14648 0.61524,0.36914 z"
     id="path2482"
     style="font-size:12px;text-anchor:middle;stroke:none" />
  <path
     d="m 219.75048,159.91129 h 90 v 20 h -90 z"
     style="font-size:12px;text-anchor:middle;fill:#9cff9c;stroke:#000000"
     id="use1430" />
  <g
     transform="translate(179.75048,159.91129)"
     id="text1432"
     aria-label="Ted Baker"
     style="font-size:12px;text-anchor:middle;stroke:none">
    <path
       id="path2486"
       d="M 61.855469,6.3066406 H 58.738281 V 14 H 57.578125 V 6.3066406 h -3.117188 v -1.03125 h 7.394532 z" />
    <path
       id="path2488"
       d="m 68.429687,10.841797 h -4.822265 q 0,0.603516 0.18164,1.054687 0.181641,0.445313 0.498047,0.732422 0.304688,0.28125 0.720703,0.421875 0.421875,0.140625 0.925782,0.140625 0.667968,0 1.341797,-0.263672 0.679687,-0.269531 0.966796,-0.527343 h 0.05859 v 1.201172 q -0.55664,0.234375 -1.136719,0.392578 -0.580078,0.158203 -1.21875,0.158203 -1.628906,0 -2.542968,-0.878906 -0.914063,-0.884766 -0.914063,-2.507813 0,-1.6054687 0.873047,-2.5488281 0.878906,-0.9433594 2.308594,-0.9433594 1.324219,0 2.039062,0.7734375 0.720703,0.7734375 0.720703,2.197266 z M 67.357422,9.9980469 Q 67.351562,9.1308594 66.917969,8.65625 66.490234,8.1816406 65.611328,8.1816406 q -0.884766,0 -1.412109,0.5214844 -0.521485,0.5214844 -0.591797,1.2949219 z" />
    <path
       id="path2490"
       d="m 75.408203,14 h -1.101562 v -0.685547 q -0.47461,0.410156 -0.990235,0.638672 -0.515625,0.228516 -1.11914,0.228516 -1.171875,0 -1.863282,-0.902344 -0.685547,-0.902344 -0.685547,-2.501953 0,-0.8320315 0.234375,-1.4824221 0.240235,-0.6503906 0.644532,-1.1074219 0.398437,-0.4453125 0.925781,-0.6796875 0.533203,-0.234375 1.101562,-0.234375 0.515625,0 0.914063,0.1113281 0.398437,0.1054688 0.837891,0.3339844 V 4.8828125 h 1.101562 z M 74.306641,12.388672 V 8.6328125 Q 73.861328,8.4335938 73.509766,8.3574219 73.158203,8.28125 72.742187,8.28125 q -0.925781,0 -1.441406,0.6445313 -0.515625,0.6445312 -0.515625,1.8281247 0,1.166016 0.398438,1.775391 0.398437,0.603516 1.277343,0.603516 0.46875,0 0.949219,-0.205079 0.480469,-0.210937 0.896485,-0.539062 z" />
    <path
       id="path2492"
       d="m 88.462891,11.316406 q 0,0.650391 -0.246094,1.148438 -0.246094,0.498047 -0.66211,0.820312 Q 87.0625,13.671875 86.470703,13.835938 85.884766,14 84.976562,14 h -3.09375 V 5.2753906 h 2.583985 q 0.955078,0 1.429687,0.070312 0.47461,0.070312 0.908203,0.2929688 0.480469,0.2519531 0.697266,0.6503906 0.216797,0.3925781 0.216797,0.9433594 0,0.6210937 -0.316406,1.0605469 -0.316407,0.4335937 -0.84375,0.6972656 v 0.046875 q 0.884765,0.1816406 1.394531,0.7792969 0.509766,0.5917972 0.509766,1.5000002 z M 86.511719,7.3847656 q 0,-0.3164062 -0.105469,-0.5332031 Q 86.300781,6.6347656 86.066406,6.5 85.791016,6.3417969 85.398437,6.3066406 85.005859,6.265625 84.425781,6.265625 h -1.382812 v 2.5195313 h 1.5 q 0.544922,0 0.867187,-0.052734 0.322266,-0.058594 0.597656,-0.234375 0.275391,-0.1757813 0.386719,-0.4511719 0.117188,-0.28125 0.117188,-0.6621098 z m 0.74414,3.9785154 q 0,-0.527343 -0.158203,-0.83789 -0.158203,-0.310547 -0.574219,-0.5273441 -0.28125,-0.1464844 -0.685546,-0.1875 -0.398438,-0.046875 -0.972657,-0.046875 h -1.822265 v 3.2460941 h 1.535156 q 0.761719,0 1.248047,-0.07617 0.486328,-0.08203 0.796875,-0.292969 0.328125,-0.228516 0.480469,-0.521484 0.152343,-0.292969 0.152343,-0.75586 z" />
    <path
       id="path2494"
       d="m 95.107422,14 h -1.095703 v -0.697266 q -0.146485,0.09961 -0.398438,0.28125 -0.246094,0.175782 -0.480469,0.28125 Q 92.857422,14 92.5,14.087891 q -0.357422,0.09375 -0.837891,0.09375 -0.884765,0 -1.5,-0.585938 -0.615234,-0.585937 -0.615234,-1.49414 0,-0.744141 0.316406,-1.201172 0.322266,-0.462891 0.914063,-0.726563 0.597656,-0.2636717 1.435547,-0.3574217 0.83789,-0.09375 1.798828,-0.140625 V 9.5058594 q 0,-0.375 -0.134766,-0.6210938 -0.128906,-0.2460937 -0.375,-0.3867187 -0.234375,-0.1347656 -0.5625,-0.1816406 -0.328125,-0.046875 -0.685547,-0.046875 -0.433594,0 -0.966797,0.1171875 -0.533203,0.1113281 -1.101562,0.328125 h -0.05859 V 7.5957031 q 0.322266,-0.087891 0.931641,-0.1933594 0.609375,-0.1054687 1.201172,-0.1054687 0.691406,0 1.201171,0.1171875 0.515625,0.1113281 0.890625,0.3867187 0.369141,0.2695313 0.5625,0.6972657 0.19336,0.4277344 0.19336,1.0605469 z m -1.095703,-1.611328 v -1.822266 q -0.503907,0.0293 -1.189453,0.08789 -0.679688,0.05859 -1.078125,0.169922 -0.47461,0.134765 -0.767579,0.421875 -0.292968,0.28125 -0.292968,0.779297 0,0.5625 0.339843,0.849609 0.339844,0.28125 1.03711,0.28125 0.580078,0 1.060547,-0.222656 0.480468,-0.228516 0.890625,-0.544922 z" />
    <path
       id="path2496"
       d="m 103.18164,14 h -1.45312 l -2.625004,-2.865234 -0.714844,0.679687 V 14 H 97.287109 V 4.8828125 h 1.101563 v 5.8476565 l 3.181638,-3.2753909 h 1.38867 l -3.041011,3.0234379 z" />
    <path
       id="path2498"
       d="m 109.82031,10.841797 h -4.82226 q 0,0.603516 0.18164,1.054687 0.18164,0.445313 0.49804,0.732422 0.30469,0.28125 0.72071,0.421875 0.42187,0.140625 0.92578,0.140625 0.66797,0 1.3418,-0.263672 0.67968,-0.269531 0.96679,-0.527343 h 0.0586 v 1.201172 q -0.55664,0.234375 -1.13672,0.392578 -0.58008,0.158203 -1.21875,0.158203 -1.62891,0 -2.54297,-0.878906 -0.91406,-0.884766 -0.91406,-2.507813 0,-1.6054687 0.87304,-2.5488281 0.87891,-0.9433594 2.3086,-0.9433594 1.32422,0 2.03906,0.7734375 0.7207,0.7734375 0.7207,2.197266 z m -1.07226,-0.8437501 q -0.006,-0.8671875 -0.43946,-1.3417969 -0.42773,-0.4746094 -1.30664,-0.4746094 -0.88476,0 -1.41211,0.5214844 -0.52148,0.5214844 -0.59179,1.2949219 z" />
    <path
       id="path2500"
       d="m 115.57422,8.65625 h -0.0586 q -0.2461,-0.058594 -0.48047,-0.082031 -0.22852,-0.029297 -0.54493,-0.029297 -0.50976,0 -0.98437,0.2285156 -0.47461,0.2226563 -0.91406,0.5800781 V 14 h -1.10157 V 7.4550781 h 1.10157 V 8.421875 q 0.65625,-0.5273438 1.15429,-0.7441406 0.50391,-0.2226563 1.02539,-0.2226563 0.28711,0 0.41602,0.017578 0.12891,0.011719 0.38672,0.052734 z" />
  </g>
  <path
     d="m 309.75048,159.91129 h 80 v 20 h -80 z"
     style="font-size:12px;text-anchor:middle;fill:#9cff9c;stroke:#000000"
     id="use1434" />
  <g
     transform="translate(179.75048,159.91129)"
     id="text1436"
     aria-label="418-4165"
     style="font-size:12px;text-anchor:middle;stroke:none">
    <path
       id="path2504"
       d="m 147.57617,11.544922 h -1.29492 V 14 h -1.125 v -2.455078 h -4.17773 v -1.347656 l 4.2246,-4.9218754 h 1.07813 v 5.3320314 h 1.29492 z m -2.41992,-0.9375 V 6.6699219 l -3.38086,3.9375001 z" />
    <path
       id="path2506"
       d="m 154.51953,14 h -4.72266 v -0.890625 h 1.81641 V 7.2617187 h -1.81641 v -0.796875 q 0.36915,0 0.79102,-0.058594 0.42188,-0.064453 0.63867,-0.1816406 0.26953,-0.1464844 0.42188,-0.3691407 0.1582,-0.2285156 0.18164,-0.609375 h 0.9082 v 7.8632816 h 1.78125 z" />
    <path
       id="path2508"
       d="m 162.72266,11.568359 q 0,1.13086 -0.88477,1.88086 -0.87891,0.75 -2.21484,0.75 -1.41797,0 -2.26172,-0.732422 -0.83789,-0.732422 -0.83789,-1.875 0,-0.726563 0.42187,-1.3125 0.42188,-0.591797 1.18946,-0.9375001 v -0.035156 q -0.70313,-0.375 -1.04297,-0.8203125 -0.33399,-0.4453125 -0.33399,-1.1132812 0,-0.984375 0.8086,-1.640625 0.80859,-0.65625 2.05664,-0.65625 1.30664,0 2.08593,0.6269531 0.7793,0.6269531 0.7793,1.59375 0,0.5917969 -0.36914,1.1660156 -0.36914,0.5683594 -1.08398,0.890625 v 0.035156 q 0.82031,0.3515625 1.2539,0.8671871 0.4336,0.515625 0.4336,1.3125 z m -1.38868,-4.2597653 q 0,-0.6269531 -0.48632,-0.9960937 -0.48047,-0.375 -1.23047,-0.375 -0.73828,0 -1.21289,0.3515625 -0.46875,0.3515625 -0.46875,0.9492187 0,0.421875 0.23437,0.7324219 0.24024,0.3046875 0.7207,0.5449219 0.2168,0.1054688 0.6211,0.2753906 0.41015,0.1699219 0.79687,0.28125 0.58008,-0.3867187 0.80274,-0.8027343 0.22265,-0.4160157 0.22265,-0.9609376 z m 0.18164,4.3710943 q 0,-0.539063 -0.24023,-0.861329 -0.23437,-0.328125 -0.92578,-0.65625 -0.27539,-0.128906 -0.60352,-0.240234 -0.32812,-0.1113281 -0.87304,-0.3105469 -0.52735,0.2871094 -0.84961,0.7792969 -0.31641,0.492188 -0.31641,1.113281 0,0.791016 0.54492,1.306641 0.54492,0.515625 1.38282,0.515625 0.85546,0 1.36523,-0.439453 0.51562,-0.439453 0.51562,-1.207031 z" />
    <path
       id="path2510"
       d="M 168.00195,10.712891 H 164.3457 V 9.6523438 h 3.65625 z" />
    <path
       id="path2512"
       d="m 175.95898,11.544922 h -1.29492 V 14 h -1.125 v -2.455078 h -4.17773 v -1.347656 l 4.22461,-4.9218754 h 1.07812 v 5.3320314 h 1.29492 z m -2.41992,-0.9375 V 6.6699219 l -3.38086,3.9375001 z" />
    <path
       id="path2514"
       d="m 182.90234,14 h -4.72265 v -0.890625 h 1.8164 V 7.2617187 h -1.8164 v -0.796875 q 0.36914,0 0.79101,-0.058594 0.42188,-0.064453 0.63867,-0.1816406 0.26954,-0.1464844 0.42188,-0.3691407 0.1582,-0.2285156 0.18164,-0.609375 h 0.9082 v 7.8632816 h 1.78125 z" />
    <path
       id="path2516"
       d="m 191.16992,11.169922 q 0,1.330078 -0.8789,2.173828 -0.87305,0.837891 -2.14454,0.837891 -0.64453,0 -1.17187,-0.199219 -0.52734,-0.199219 -0.93164,-0.591797 -0.50391,-0.486328 -0.7793,-1.289062 -0.26953,-0.802735 -0.26953,-1.933594 0,-1.1601565 0.24609,-2.0566409 0.25196,-0.8964844 0.79688,-1.59375 0.51562,-0.6621094 1.33008,-1.03125 0.81445,-0.375 1.89843,-0.375 0.34571,0 0.58008,0.029297 0.23438,0.029297 0.47461,0.1054687 v 1.1191407 h -0.0586 q -0.16406,-0.087891 -0.49805,-0.1640625 -0.32812,-0.082031 -0.67383,-0.082031 -1.25976,0 -2.00976,0.7910156 -0.75,0.7851563 -0.87305,2.1269532 0.49219,-0.2988281 0.9668,-0.4511719 0.48047,-0.1582031 1.10742,-0.1582031 0.55664,0 0.97852,0.1054687 0.42773,0.099609 0.87304,0.4101563 0.51563,0.3574219 0.77344,0.9023437 0.26367,0.5449215 0.26367,1.3242185 z m -1.18945,0.04687 q 0,-0.544922 -0.16406,-0.902344 -0.15821,-0.3574217 -0.52735,-0.6210936 -0.26953,-0.1875 -0.59765,-0.2460938 -0.32813,-0.058594 -0.68555,-0.058594 -0.49805,0 -0.92578,0.1171875 -0.42774,0.1171875 -0.87891,0.3632812 -0.0117,0.1289063 -0.0176,0.2519537 -0.006,0.117187 -0.006,0.298828 0,0.925781 0.1875,1.464844 0.19336,0.533203 0.52735,0.84375 0.26953,0.257812 0.58008,0.380859 0.3164,0.117188 0.68554,0.117188 0.84961,0 1.33594,-0.515625 0.48633,-0.521485 0.48633,-1.494141 z" />
    <path
       id="path2518"
       d="m 198.61133,11.228516 q 0,0.609375 -0.22266,1.166015 -0.22265,0.556641 -0.60937,0.9375 -0.42188,0.410157 -1.00782,0.632813 -0.58007,0.216797 -1.34765,0.216797 -0.71485,0 -1.37696,-0.152344 -0.6621,-0.146484 -1.11914,-0.357422 v -1.236328 h 0.082 q 0.48046,0.304687 1.125,0.521484 0.64453,0.210938 1.26562,0.210938 0.41602,0 0.80273,-0.117188 0.39258,-0.117187 0.69727,-0.410156 0.25781,-0.251953 0.38672,-0.603516 0.13476,-0.351562 0.13476,-0.814453 0,-0.451172 -0.1582,-0.761718 -0.15234,-0.310547 -0.42773,-0.4980474 -0.30469,-0.2226562 -0.74414,-0.3105468 -0.4336,-0.09375 -0.97266,-0.09375 -0.51562,0 -0.99609,0.070312 -0.47461,0.070312 -0.82032,0.140625 V 5.2753906 h 5.25 v 1.0253906 h -4.11914 v 2.3203126 q 0.25196,-0.023437 0.51563,-0.035156 0.26367,-0.011719 0.45703,-0.011719 0.70898,0 1.24219,0.1230468 0.5332,0.1171875 0.97851,0.421875 0.46875,0.3222657 0.72657,0.8320313 0.25781,0.5097661 0.25781,1.2773441 z" />
  </g>
  <path
     d="m 389.75048,159.91129 h 20 v 20 h -20 z"
     style="font-size:12px;text-anchor:middle;fill:#9cff9c;stroke:#000000"
     id="use1438" />
  <path
     d="m 399.75048,169.91129 h 0.001"
     style="font-size:12px;text-anchor:middle;stroke:#000000;marker-start:url(#linkdot_N)"
     id="line1440" />
  <path
     d="m 182.75048,180.91129 h 34 v 18 h -34 z"
     style="font-size:12px;text-anchor:middle;fill:#a8a8ff;stroke:none"
     id="use1482" />
  <path
     d="m 210.61962,191.45621 h -1.29492 v 2.45508 h -1.125 v -2.45508 h -4.17774 v -1.34765 l 4.22461,-4.92188 h 1.07813 v 5.33203 h 1.29492 z m -2.41992,-0.9375 v -3.9375 l -3.38086,3.9375 z"
     id="path2564"
     style="font-size:12px;text-anchor:middle;stroke:none" />
  <path
     d="m 219.75048,179.91129 h 90 v 20 h -90 z"
     style="font-size:12px;text-anchor:middle;fill:#9cff9c;stroke:#000000"
     id="use1486" />
  <g
     transform="translate(179.75048,179.91129)"
     id="text1488"
     aria-label="Sam Doe"
     style="font-size:12px;text-anchor:middle;stroke:none">
    <path
       id="path2568"
       d="m 65.007812,11.509766 q 0,0.509765 -0.240234,1.007812 -0.234375,0.498047 -0.662109,0.84375 -0.46875,0.375 -1.095703,0.585938 -0.621094,0.210937 -1.5,0.210937 -0.94336,0 -1.699219,-0.175781 -0.75,-0.175781 -1.529297,-0.521484 v -1.453125 h 0.08203 q 0.66211,0.550781 1.529297,0.849609 0.867188,0.298828 1.628906,0.298828 1.078125,0 1.675782,-0.404297 0.603515,-0.404297 0.603515,-1.078125 0,-0.580078 -0.287109,-0.855469 -0.28125,-0.27539 -0.861328,-0.427734 -0.439453,-0.117187 -0.955078,-0.193359 -0.509766,-0.07617 -1.083985,-0.19336 -1.160156,-0.2460935 -1.722656,-0.8378904 -0.556641,-0.5976562 -0.556641,-1.5527344 0,-1.0957031 0.925782,-1.7929687 0.925781,-0.703125 2.349609,-0.703125 0.919922,0 1.6875,0.1757812 0.767578,0.1757813 1.359375,0.4335938 v 1.3710937 h -0.08203 q -0.498047,-0.421875 -1.3125,-0.6972656 -0.808594,-0.28125 -1.658203,-0.28125 -0.931641,0 -1.5,0.3867188 -0.5625,0.3867187 -0.5625,0.9960937 0,0.5449219 0.28125,0.8554688 0.28125,0.3105469 0.990234,0.4746094 0.375,0.082031 1.066406,0.1992187 0.691406,0.1171875 1.171875,0.2402344 0.972656,0.2578125 1.464844,0.7792966 0.492187,0.521485 0.492187,1.458985 z" />
    <path
       id="path2570"
       d="m 71.869141,14 h -1.095704 v -0.697266 q -0.146484,0.09961 -0.398437,0.28125 -0.246094,0.175782 -0.480469,0.28125 -0.27539,0.134766 -0.632812,0.222657 -0.357422,0.09375 -0.837891,0.09375 -0.884766,0 -1.5,-0.585938 -0.615234,-0.585937 -0.615234,-1.49414 0,-0.744141 0.316406,-1.201172 0.322266,-0.462891 0.914062,-0.726563 0.597657,-0.2636717 1.435547,-0.3574217 0.837891,-0.09375 1.798828,-0.140625 V 9.5058594 q 0,-0.375 -0.134765,-0.6210938 -0.128906,-0.2460937 -0.375,-0.3867187 -0.234375,-0.1347656 -0.5625,-0.1816406 -0.328125,-0.046875 -0.685547,-0.046875 -0.433594,0 -0.966797,0.1171875 -0.533203,0.1113281 -1.101562,0.328125 h -0.05859 V 7.5957031 q 0.322265,-0.087891 0.93164,-0.1933594 0.609375,-0.1054687 1.201172,-0.1054687 0.691407,0 1.201172,0.1171875 0.515625,0.1113281 0.890625,0.3867187 0.369141,0.2695313 0.5625,0.6972657 0.19336,0.4277344 0.19336,1.0605469 z m -1.095704,-1.611328 v -1.822266 q -0.503906,0.0293 -1.189453,0.08789 -0.679687,0.05859 -1.078125,0.169922 -0.474609,0.134765 -0.767578,0.421875 -0.292969,0.28125 -0.292969,0.779297 0,0.5625 0.339844,0.849609 0.339844,0.28125 1.03711,0.28125 0.580078,0 1.060546,-0.222656 0.480469,-0.228516 0.890625,-0.544922 z" />
    <path
       id="path2572"
       d="m 83.552734,14 h -1.101562 v -3.726562 q 0,-0.4218755 -0.04102,-0.8144536 Q 82.375,9.0664063 82.251953,8.8320313 82.117187,8.5800781 81.865234,8.4511719 81.613281,8.3222656 81.138672,8.3222656 q -0.462891,0 -0.925781,0.234375 -0.462891,0.2285157 -0.925782,0.5859375 0.01758,0.1347657 0.0293,0.3164063 0.01172,0.1757812 0.01172,0.3515625 V 14 h -1.101563 v -3.726562 q 0,-0.4335942 -0.04102,-0.820313 -0.03516,-0.3925781 -0.158203,-0.6269531 -0.134766,-0.2519531 -0.386719,-0.375 -0.251953,-0.1289063 -0.726563,-0.1289063 -0.451171,0 -0.908203,0.2226563 -0.451172,0.2226562 -0.902343,0.5683594 V 14 H 74.001953 V 7.4550781 h 1.101563 v 0.7265625 q 0.515625,-0.4277344 1.02539,-0.6679687 0.515625,-0.2402344 1.095703,-0.2402344 0.667969,0 1.13086,0.28125 0.46875,0.28125 0.697265,0.7792969 0.667969,-0.5625 1.21875,-0.8085938 0.550782,-0.2519531 1.177735,-0.2519531 1.078125,0 1.58789,0.65625 0.515625,0.6503906 0.515625,1.8222656 z" />
    <path
       id="path2574"
       d="m 97.351562,9.6464844 q 0,1.1894536 -0.521484,2.1562496 -0.515625,0.966797 -1.376953,1.5 -0.597656,0.369141 -1.335938,0.533204 Q 93.384766,14 92.183594,14 H 89.980469 V 5.2753906 h 2.179687 q 1.277344,0 2.027344,0.1875 0.755859,0.1816406 1.277344,0.5039063 0.890625,0.5566406 1.388672,1.4824218 0.498046,0.9257813 0.498046,2.1972657 z m -1.21289,-0.017578 q 0,-1.0253907 -0.357422,-1.7285157 Q 95.423828,7.1972656 94.714844,6.7929687 94.199219,6.5 93.619141,6.3886719 93.039062,6.2714844 92.230469,6.2714844 h -1.089844 v 6.7324216 h 1.089844 q 0.83789,0 1.458984,-0.123047 0.626953,-0.123046 1.148438,-0.457031 0.65039,-0.416015 0.972656,-1.095703 0.328125,-0.679687 0.328125,-1.6992186 z" />
    <path
       id="path2576"
       d="m 104.72852,10.730469 q 0,1.599609 -0.82032,2.52539 -0.82031,0.925782 -2.19726,0.925782 -1.38867,0 -2.208987,-0.925782 -0.814453,-0.925781 -0.814453,-2.52539 0,-1.5996096 0.814453,-2.5253909 0.820317,-0.9316406 2.208987,-0.9316406 1.37695,0 2.19726,0.9316406 0.82032,0.9257813 0.82032,2.5253909 z m -1.13672,0 q 0,-1.2714846 -0.49805,-1.886719 -0.49805,-0.6210937 -1.38281,-0.6210937 -0.89649,0 -1.39453,0.6210937 -0.492191,0.6152344 -0.492191,1.886719 0,1.230469 0.498051,1.86914 0.49804,0.632813 1.38867,0.632813 0.8789,0 1.37695,-0.626953 0.50391,-0.632813 0.50391,-1.875 z" />
    <path
       id="path2578"
       d="m 111.91797,10.841797 h -4.82227 q 0,0.603516 0.18164,1.054687 0.18164,0.445313 0.49805,0.732422 0.30469,0.28125 0.7207,0.421875 0.42188,0.140625 0.92579,0.140625 0.66796,0 1.34179,-0.263672 0.67969,-0.269531 0.9668,-0.527343 h 0.0586 v 1.201172 q -0.55664,0.234375 -1.13672,0.392578 -0.58007,0.158203 -1.21875,0.158203 -1.6289,0 -2.54296,-0.878906 -0.91407,-0.884766 -0.91407,-2.507813 0,-1.6054687 0.87305,-2.5488281 0.87891,-0.9433594 2.30859,-0.9433594 1.32422,0 2.03907,0.7734375 0.7207,0.7734375 0.7207,2.197266 z M 110.8457,9.9980469 q -0.006,-0.8671875 -0.43945,-1.3417969 -0.42773,-0.4746094 -1.30664,-0.4746094 -0.88477,0 -1.41211,0.5214844 -0.52148,0.5214844 -0.5918,1.2949219 z" />
  </g>
  <path
     d="m 309.75048,179.91129 h 80 v 20 h -80 z"
     style="font-size:12px;text-anchor:middle;fill:#9cff9c;stroke:#000000"
     id="use1490" />
  <g
     transform="translate(179.75048,179.91129)"
     id="text1492"
     aria-label="521-5030"
     style="font-size:12px;text-anchor:middle;stroke:none">
    <path
       id="path2582"
       d="m 147.30664,11.228516 q 0,0.609375 -0.22266,1.166015 -0.22265,0.556641 -0.60937,0.9375 -0.42188,0.410157 -1.00781,0.632813 -0.58008,0.216797 -1.34766,0.216797 -0.71484,0 -1.37695,-0.152344 -0.66211,-0.146484 -1.11914,-0.357422 v -1.236328 h 0.082 q 0.48047,0.304687 1.125,0.521484 0.64453,0.210938 1.26562,0.210938 0.41602,0 0.80274,-0.117188 0.39258,-0.117187 0.69726,-0.410156 0.25782,-0.251953 0.38672,-0.603516 0.13477,-0.351562 0.13477,-0.814453 0,-0.451172 -0.15821,-0.761718 -0.15234,-0.310547 -0.42773,-0.4980474 -0.30469,-0.2226562 -0.74414,-0.3105468 -0.43359,-0.09375 -0.97266,-0.09375 -0.51562,0 -0.99609,0.070312 -0.47461,0.070312 -0.82031,0.140625 V 5.2753906 h 5.25 v 1.0253906 h -4.11914 v 2.3203126 q 0.25195,-0.023437 0.51562,-0.035156 0.26367,-0.011719 0.45703,-0.011719 0.70899,0 1.24219,0.1230468 0.5332,0.1171875 0.97852,0.421875 0.46875,0.3222657 0.72656,0.8320313 0.25781,0.5097661 0.25781,1.2773441 z" />
    <path
       id="path2584"
       d="m 155.01758,14 h -5.90625 v -1.224609 q 0.61523,-0.527344 1.23047,-1.054688 0.62109,-0.527344 1.15429,-1.048828 1.125,-1.0898437 1.54102,-1.7285156 0.41601,-0.6445313 0.41601,-1.3886719 0,-0.6796875 -0.45117,-1.0605469 -0.44531,-0.3867187 -1.24804,-0.3867187 -0.53321,0 -1.1543,0.1875 -0.62109,0.1875 -1.21289,0.5742187 h -0.0586 V 5.6386719 q 0.41602,-0.2050782 1.10743,-0.375 0.69726,-0.1699219 1.34765,-0.1699219 1.3418,0 2.10352,0.6503906 0.76172,0.6445313 0.76172,1.7519531 0,0.4980469 -0.12891,0.9316407 -0.12305,0.4277344 -0.36914,0.8144531 -0.22852,0.3632813 -0.53906,0.7148438 -0.30469,0.3515627 -0.74414,0.7792967 -0.62696,0.615235 -1.29492,1.195313 -0.66797,0.574218 -1.24805,1.066406 h 4.69336 z" />
    <path
       id="path2586"
       d="m 162.16016,14 h -4.72266 v -0.890625 h 1.81641 V 7.2617187 h -1.81641 v -0.796875 q 0.36914,0 0.79102,-0.058594 0.42187,-0.064453 0.63867,-0.1816406 0.26953,-0.1464844 0.42187,-0.3691407 0.15821,-0.2285156 0.18164,-0.609375 h 0.90821 v 7.8632816 h 1.78125 z" />
    <path
       id="path2588"
       d="M 168.00195,10.712891 H 164.3457 V 9.6523438 h 3.65625 z" />
    <path
       id="path2590"
       d="m 175.68945,11.228516 q 0,0.609375 -0.22265,1.166015 -0.22266,0.556641 -0.60938,0.9375 -0.42187,0.410157 -1.00781,0.632813 -0.58008,0.216797 -1.34766,0.216797 -0.71484,0 -1.37695,-0.152344 -0.66211,-0.146484 -1.11914,-0.357422 v -1.236328 h 0.082 q 0.48047,0.304687 1.125,0.521484 0.64453,0.210938 1.26563,0.210938 0.41601,0 0.80273,-0.117188 0.39258,-0.117187 0.69727,-0.410156 0.25781,-0.251953 0.38671,-0.603516 0.13477,-0.351562 0.13477,-0.814453 0,-0.451172 -0.1582,-0.761718 -0.15235,-0.310547 -0.42774,-0.4980474 -0.30469,-0.2226562 -0.74414,-0.3105468 -0.43359,-0.09375 -0.97265,-0.09375 -0.51563,0 -0.9961,0.070312 -0.47461,0.070312 -0.82031,0.140625 V 5.2753906 h 5.25 v 1.0253906 h -4.11914 v 2.3203126 q 0.25195,-0.023437 0.51562,-0.035156 0.26368,-0.011719 0.45703,-0.011719 0.70899,0 1.24219,0.1230468 0.53321,0.1171875 0.97852,0.421875 0.46875,0.3222657 0.72656,0.8320313 0.25781,0.5097661 0.25781,1.2773441 z" />
    <path
       id="path2592"
       d="m 183.38867,9.6347656 q 0,2.3496094 -0.73828,3.4511724 -0.73242,1.095703 -2.2793,1.095703 -1.57031,0 -2.29687,-1.113282 -0.7207,-1.113281 -0.7207,-3.4218746 0,-2.3261719 0.73242,-3.4335938 0.73242,-1.1132812 2.28515,-1.1132812 1.57032,0 2.29102,1.1308593 0.72656,1.125 0.72656,3.4042969 z m -1.54101,2.6601564 q 0.20507,-0.474609 0.27539,-1.113281 0.0762,-0.644532 0.0762,-1.5468754 0,-0.890625 -0.0762,-1.546875 -0.0703,-0.65625 -0.28125,-1.1132812 -0.20508,-0.4511719 -0.5625,-0.6796875 -0.35157,-0.2285157 -0.90821,-0.2285157 -0.55078,0 -0.91406,0.2285157 -0.35742,0.2285156 -0.56836,0.6914062 -0.19922,0.4335938 -0.27539,1.1308594 -0.0703,0.6972656 -0.0703,1.5292969 0,0.9140626 0.0644,1.5292966 0.0645,0.615235 0.27539,1.101563 0.19336,0.457031 0.54492,0.697265 0.35743,0.240235 0.94336,0.240235 0.55078,0 0.91407,-0.228516 0.36328,-0.228515 0.5625,-0.691406 z" />
    <path
       id="path2594"
       d="m 190.27344,9.7988281 q 0.28125,0.2519529 0.46289,0.6328129 0.18164,0.380859 0.18164,0.984375 0,0.597656 -0.2168,1.095703 -0.2168,0.498047 -0.60937,0.867187 -0.43946,0.410157 -1.03711,0.609375 -0.5918,0.19336 -1.30078,0.19336 -0.72657,0 -1.42969,-0.175782 -0.70313,-0.169921 -1.1543,-0.375 V 12.40625 h 0.0879 q 0.49805,0.328125 1.17188,0.544922 0.67383,0.216797 1.30078,0.216797 0.36914,0 0.78515,-0.123047 0.41602,-0.123047 0.67383,-0.363281 0.26953,-0.257813 0.39844,-0.56836 0.13477,-0.310547 0.13477,-0.785156 0,-0.46875 -0.15235,-0.773437 -0.14648,-0.310547 -0.41015,-0.486329 -0.26368,-0.1816402 -0.63868,-0.2460934 -0.375,-0.070312 -0.80859,-0.070312 h -0.52734 V 8.7792969 h 0.41015 q 0.89063,0 1.41797,-0.3691406 0.5332,-0.375 0.5332,-1.0898438 0,-0.3164063 -0.13476,-0.5507813 -0.13477,-0.2402343 -0.375,-0.3925781 -0.25195,-0.1523437 -0.53906,-0.2109375 -0.28711,-0.058594 -0.65039,-0.058594 -0.55664,0 -1.1836,0.1992187 -0.62695,0.1992188 -1.18359,0.5625 h -0.0586 V 5.6445312 q 0.41602,-0.2050781 1.10743,-0.375 0.69726,-0.1757812 1.34765,-0.1757812 0.63867,0 1.125,0.1171875 0.48633,0.1171875 0.87891,0.375 0.42187,0.28125 0.63867,0.6796875 0.2168,0.3984375 0.2168,0.9316406 0,0.7265625 -0.51563,1.2714844 -0.50976,0.5390625 -1.20703,0.6796875 v 0.082031 q 0.28125,0.046875 0.64453,0.1992187 0.36328,0.1464844 0.61524,0.3691406 z" />
    <path
       id="path2596"
       d="m 198.66992,9.6347656 q 0,2.3496094 -0.73828,3.4511724 -0.73242,1.095703 -2.2793,1.095703 -1.57031,0 -2.29687,-1.113282 -0.7207,-1.113281 -0.7207,-3.4218746 0,-2.3261719 0.73242,-3.4335938 0.73242,-1.1132812 2.28515,-1.1132812 1.57032,0 2.29102,1.1308593 0.72656,1.125 0.72656,3.4042969 z m -1.54101,2.6601564 q 0.20507,-0.474609 0.27539,-1.113281 0.0762,-0.644532 0.0762,-1.5468754 0,-0.890625 -0.0762,-1.546875 -0.0703,-0.65625 -0.28125,-1.1132812 -0.20508,-0.4511719 -0.5625,-0.6796875 -0.35157,-0.2285157 -0.90821,-0.2285157 -0.55078,0 -0.91406,0.2285157 -0.35742,0.2285156 -0.56836,0.6914062 -0.19922,0.4335938 -0.27539,1.1308594 -0.0703,0.6972656 -0.0703,1.5292969 0,0.9140626 0.0644,1.5292966 0.0645,0.615235 0.27539,1.101563 0.19336,0.457031 0.54492,0.697265 0.35743,0.240235 0.94336,0.240235 0.55078,0 0.91407,-0.228516 0.36328,-0.228515 0.5625,-0.691406 z" />
  </g>
  <path
     d="m 389.75048,179.91129 h 20 v 20 h -20 z"
     style="font-size:12px;text-anchor:middle;fill:#9cff9c;stroke:#000000"
     id="use1494" />
  <path
     d="m 399.75048,189.91129 h 0.001"
     style="font-size:12px;text-anchor:middle;stroke:#000000;marker-start:url(#linkdot_N)"
     id="line1496" />
  <path
     id="path4268"
     d="m 100,121.10131 30.65168,8.80998"
     style="fill:none;stroke:#000000;stroke-width:1.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
  <path
     id="path4270"
     d="m 100,161.10131 30.63751,28.80998"
     style="fill:none;stroke:#000000;stroke-width:1.5;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1" />
  <path
     d="m 421.4415,270.35918 h 34 v 18 h -34 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;stroke:none;stroke-width:0.999999"
     id="use1338-1" />
  <path
     d="m 449.0997,278.99393 q 0,2.34962 -0.73828,3.45116 -0.73242,1.09572 -2.2793,1.09572 -1.57031,0 -2.29687,-1.11329 -0.7207,-1.11326 -0.7207,-3.42187 0,-2.32615 0.73242,-3.43359 0.73242,-1.11326 2.28515,-1.11326 1.57032,0 2.29102,1.13083 0.72656,1.12502 0.72656,3.4043 z m -1.54101,2.66018 q 0.20507,-0.47463 0.27537,-1.1133 0.0762,-0.64452 0.0762,-1.54688 0,-0.89061 -0.0762,-1.54689 -0.0703,-0.65623 -0.28123,-1.11326 -0.20508,-0.45116 -0.5625,-0.67967 -0.35157,-0.22866 -0.90821,-0.22866 -0.55078,0 -0.91406,0.22866 -0.35743,0.22866 -0.56836,0.69139 -0.19922,0.43359 -0.27538,1.13087 -0.0703,0.69725 -0.0703,1.52928 0,0.91407 0.0644,1.52931 0.0644,0.61523 0.27537,1.10158 0.19336,0.45702 0.54492,0.69724 0.35743,0.24038 0.94336,0.24038 0.55079,0 0.91407,-0.22866 0.36329,-0.22866 0.5625,-0.69139 z"
     id="path2338-2"
     style="font-size:12px;text-anchor:middle;stroke:none;stroke-width:0.999999" />
  <path
     d="m 458.4415,269.35916 h 90 v 20.00001 h -90 z"
     style="font-size:12px;text-anchor:middle;fill:#9cff9c;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     id="use1342-0" />
  <path
     d="m 548.4415,269.35916 h 80.00001 v 20.00001 H 548.4415 Z"
     style="font-size:12px;text-anchor:middle;fill:#9cff9c;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     id="use1344-9" />
  <path
     d="m 421.4415,290.35916 h 34 v 18 h -34 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;fill-opacity:1;stroke:none;stroke-width:0.999999"
     id="use1352-8" />
  <path
     d="m 448.61337,303.35918 h -4.72265 v -0.89064 h 1.8164 v -5.84765 h -1.8164 v -0.79688 q 0.36915,0 0.79101,-0.0586 0.42188,-0.0643 0.63868,-0.18179 0.26952,-0.14627 0.42187,-0.36926 0.15821,-0.22866 0.18164,-0.60937 h 0.9082 v 7.86327 h 1.78125 z"
     id="path2350-9"
     style="font-size:12px;text-anchor:middle;stroke:none;stroke-width:0.999999" />
  <path
     d="m 458.4415,289.35917 h 90 v 20.00001 h -90 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     id="use1356-5" />
  <path
     d="m 548.4415,289.35917 h 80.00001 v 20.00001 H 548.4415 Z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     id="use1360-8" />
  <path
     d="m 421.4415,310.35917 h 34 v 18 h -34 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;fill-opacity:1;stroke:none;stroke-width:0.999999"
     id="use1408-2" />
  <path
     d="m 449.11142,323.35916 h -5.90625 v -1.22461 q 0.61524,-0.52732 1.23047,-1.05467 0.62109,-0.52736 1.1543,-1.04882 1.125,-1.08987 1.54101,-1.72853 0.41602,-0.64452 0.41602,-1.38868 0,-0.67967 -0.45117,-1.06053 -0.44532,-0.38672 -1.24805,-0.38672 -0.5332,0 -1.15431,0.18746 -0.62108,0.18747 -1.21288,0.57423 h -0.0586 v -1.2305 q 0.41602,-0.20523 1.10742,-0.37493 0.69727,-0.17008 1.34766,-0.17008 1.3418,0 2.10351,0.65042 0.76171,0.64452 0.76171,1.75192 0,0.49807 -0.12888,0.93165 -0.12306,0.42773 -0.36914,0.81445 -0.22851,0.36322 -0.53906,0.71486 -0.30471,0.3515 -0.74415,0.77931 -0.62695,0.61523 -1.29492,1.19531 -0.66797,0.57422 -1.24805,1.06639 h 4.69337 z"
     id="path2434-3"
     style="font-size:12px;text-anchor:middle;stroke:none;stroke-width:0.999999" />
  <path
     d="m 458.4415,309.35918 h 90 v 19.99998 h -90 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     id="use1412-0" />
  <path
     d="m 548.4415,309.35918 h 80.00001 v 19.99998 H 548.4415 Z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     id="use1416-6" />
  <path
     d="m 421.4415,330.35918 h 34 v 18 h -34 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;fill-opacity:1;stroke:none;stroke-width:0.999999"
     id="use1426-5" />
  <path
     d="m 448.34384,339.158 q 0.28123,0.25209 0.46289,0.63281 0.18164,0.38086 0.18164,0.98437 0,0.59766 -0.21679,1.09573 -0.2168,0.49803 -0.60938,0.86717 -0.43945,0.41016 -1.03711,0.60937 -0.59179,0.19352 -1.30078,0.19352 -0.72656,0 -1.42969,-0.17575 -0.70312,-0.17008 -1.15429,-0.37493 v -1.22461 h 0.0879 q 0.49804,0.32807 1.17187,0.5449 0.67383,0.21694 1.30078,0.21694 0.36914,0 0.78516,-0.12321 0.41602,-0.12321 0.67383,-0.36321 0.26952,-0.25776 0.39844,-0.56833 0.13474,-0.31068 0.13474,-0.7852 0,-0.46873 -0.15235,-0.7734 -0.1465,-0.31068 -0.41016,-0.48635 -0.26366,-0.1818 -0.63867,-0.24605 -0.37501,-0.0703 -0.80859,-0.0703 h -0.52735 v -0.97262 h 0.41016 q 0.89062,0 1.41797,-0.36926 0.53319,-0.37493 0.53319,-1.08987 0,-0.31634 -0.13474,-0.55079 -0.13477,-0.24037 -0.375,-0.39258 -0.25194,-0.15231 -0.53907,-0.21089 -0.28709,-0.0586 -0.65039,-0.0586 -0.55664,0 -1.18359,0.19918 -0.62695,0.19918 -1.1836,0.5625 h -0.0586 v -1.2246 q 0.41602,-0.20523 1.10743,-0.37493 0.69726,-0.17575 1.34765,-0.17575 0.63867,0 1.125,0.11717 0.48633,0.11716 0.87891,0.37493 0.42188,0.28119 0.63867,0.67967 0.21679,0.39844 0.21679,0.93165 0,0.72658 -0.51563,1.27147 -0.50976,0.53908 -1.20703,0.67971 v 0.082 q 0.28124,0.0469 0.64453,0.19918 0.36329,0.14665 0.61524,0.36926 z"
     id="path2482-8"
     style="font-size:12px;text-anchor:middle;stroke:none;stroke-width:0.999999" />
  <path
     d="m 458.4415,329.35916 h 90 v 20.00001 h -90 z"
     style="font-size:12px;text-anchor:middle;fill:#9cff9c;stroke:#000000;stroke-width:0.999999"
     id="use1430-6" />
  <path
     d="m 548.4415,329.35916 h 80.00001 v 20.00001 H 548.4415 Z"
     style="font-size:12px;text-anchor:middle;fill:#9cff9c;stroke:#000000;stroke-width:0.999999"
     id="use1434-6" />
  <path
     d="m 421.4415,350.35916 h 34 v 18 h -34 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;fill-opacity:1;stroke:none;stroke-width:0.999999"
     id="use1482-8" />
  <path
     d="m 449.31064,360.90408 h -1.29492 v 2.4551 h -1.125 v -2.4551 h -4.17774 v -1.34763 l 4.22461,-4.92189 h 1.07813 v 5.33204 h 1.29492 z m -2.41992,-0.93748 v -3.93751 l -3.38086,3.93751 z"
     id="path2564-1"
     style="font-size:12px;text-anchor:middle;stroke:none;stroke-width:0.999999" />
  <path
     d="m 458.4415,349.35917 h 90 v 20.00002 h -90 z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     id="use1486-3" />
  <path
     d="m 548.4415,349.35917 h 80.00001 v 20.00002 H 548.4415 Z"
     style="font-size:12px;text-anchor:middle;fill:#ddeedd;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     id="use1490-5" />
  <g
     style="font-size:12px;text-anchor:middle;stroke:none"
     id="text1414-1"
     aria-label="John Smith"
     transform="translate(418.83115,329.82694)">
    <path
       id="path2438-5"
       d="m 55.539062,11.732422 q 0,1.148437 -0.703125,1.769531 -0.697265,0.621094 -1.875,0.621094 -0.28125,0 -0.75,-0.05273 -0.46875,-0.04687 -0.785156,-0.117188 v -1.083984 h 0.06445 q 0.240235,0.08203 0.591797,0.169922 0.351563,0.08789 0.720703,0.08789 0.539063,0 0.855469,-0.123047 0.322266,-0.123047 0.474609,-0.351562 0.158204,-0.234375 0.199219,-0.574219 0.04687,-0.339844 0.04687,-0.785156 V 6.2011719 H 52.533203 V 5.2753906 h 3.005859 z" />
    <path
       id="path2440-7"
       d="m 63.291016,10.730469 q 0,1.599609 -0.820313,2.52539 -0.820312,0.925782 -2.197266,0.925782 -1.388671,0 -2.208984,-0.925782 Q 57.25,12.330078 57.25,10.730469 q 0,-1.5996096 0.814453,-2.5253909 0.820313,-0.9316406 2.208984,-0.9316406 1.376954,0 2.197266,0.9316406 0.820313,0.9257813 0.820313,2.5253909 z m -1.136719,0 q 0,-1.2714846 -0.498047,-1.886719 -0.498047,-0.6210937 -1.382813,-0.6210937 -0.896484,0 -1.394531,0.6210937 -0.492187,0.6152344 -0.492187,1.886719 0,1.230469 0.498047,1.86914 0.498046,0.632813 1.388671,0.632813 0.878907,0 1.376954,-0.626953 0.503906,-0.632813 0.503906,-1.875 z" />
    <path
       id="path2442-7"
       d="m 70.474609,14 h -1.101562 v -3.726562 q 0,-0.4511724 -0.05273,-0.8437505 Q 69.267578,9.03125 69.126953,8.8085938 68.980469,8.5625 68.705078,8.4453125 68.429687,8.3222656 67.990234,8.3222656 q -0.451172,0 -0.943359,0.2226563 -0.492188,0.2226562 -0.943359,0.5683594 V 14 H 65.001953 V 4.8828125 h 1.101563 v 3.2988281 q 0.515625,-0.4277344 1.066406,-0.6679687 0.550781,-0.2402344 1.130859,-0.2402344 1.060547,0 1.617188,0.6386719 0.55664,0.6386719 0.55664,1.8398437 z" />
    <path
       id="path2444-2"
       d="m 78.068359,14 h -1.101562 v -3.726562 q 0,-0.4511724 -0.05273,-0.8437505 Q 76.861328,9.03125 76.720703,8.8085938 76.574219,8.5625 76.298828,8.4453125 76.023437,8.3222656 75.583984,8.3222656 q -0.451172,0 -0.943359,0.2226563 -0.492188,0.2226562 -0.943359,0.5683594 V 14 H 72.595703 V 7.4550781 h 1.101563 v 0.7265625 q 0.515625,-0.4277344 1.066406,-0.6679687 0.550781,-0.2402344 1.130859,-0.2402344 1.060547,0 1.617188,0.6386719 0.55664,0.6386719 0.55664,1.8398437 z" />
    <path
       id="path2446-8"
       d="m 90.835937,11.509766 q 0,0.509765 -0.240234,1.007812 -0.234375,0.498047 -0.662109,0.84375 -0.46875,0.375 -1.095703,0.585938 -0.621094,0.210937 -1.5,0.210937 -0.94336,0 -1.699219,-0.175781 -0.75,-0.175781 -1.529297,-0.521484 v -1.453125 h 0.08203 q 0.66211,0.550781 1.529297,0.849609 0.867188,0.298828 1.628906,0.298828 1.078125,0 1.675782,-0.404297 0.603515,-0.404297 0.603515,-1.078125 0,-0.580078 -0.287109,-0.855469 -0.28125,-0.27539 -0.861328,-0.427734 -0.439453,-0.117187 -0.955078,-0.193359 -0.509766,-0.07617 -1.083985,-0.19336 Q 85.28125,9.7578125 84.71875,9.1660156 84.162109,8.5683594 84.162109,7.6132812 q 0,-1.0957031 0.925782,-1.7929687 0.925781,-0.703125 2.349609,-0.703125 0.919922,0 1.6875,0.1757812 0.767578,0.1757813 1.359375,0.4335938 v 1.3710937 h -0.08203 q -0.498047,-0.421875 -1.3125,-0.6972656 -0.808594,-0.28125 -1.658203,-0.28125 -0.931641,0 -1.5,0.3867188 -0.5625,0.3867187 -0.5625,0.9960937 0,0.5449219 0.28125,0.8554688 0.28125,0.3105469 0.990234,0.4746094 0.375,0.082031 1.066406,0.1992187 0.691406,0.1171875 1.171875,0.2402344 0.972656,0.2578125 1.464844,0.7792966 0.492187,0.521485 0.492186,1.458985 z" />
    <path
       id="path2448-4"
       d="m 102.16211,14 h -1.10156 v -3.726562 q 0,-0.4218755 -0.041,-0.8144536 -0.0352,-0.3925781 -0.1582,-0.6269531 -0.13477,-0.2519532 -0.38672,-0.3808594 -0.25195,-0.1289063 -0.726563,-0.1289063 -0.462891,0 -0.925781,0.234375 -0.462891,0.2285157 -0.925782,0.5859375 0.01758,0.1347657 0.0293,0.3164063 0.01172,0.1757812 0.01172,0.3515625 V 14 h -1.101563 v -3.726562 q 0,-0.4335942 -0.04102,-0.820313 Q 96.759766,9.0605469 96.636719,8.8261719 96.501953,8.5742188 96.25,8.4511719 95.998047,8.3222656 95.523437,8.3222656 q -0.451171,0 -0.908203,0.2226563 -0.451172,0.2226562 -0.902343,0.5683594 V 14 H 92.611328 V 7.4550781 h 1.101563 v 0.7265625 q 0.515625,-0.4277344 1.02539,-0.6679687 0.515625,-0.2402344 1.095703,-0.2402344 0.667969,0 1.13086,0.28125 0.46875,0.28125 0.697265,0.7792969 0.667969,-0.5625 1.21875,-0.8085938 0.550782,-0.2519531 1.177731,-0.2519531 1.07813,0 1.58789,0.65625 0.51563,0.6503906 0.51563,1.8222656 z" />
    <path
       id="path2450-9"
       d="m 105.4668,6.359375 h -1.24219 V 5.2167969 h 1.24219 z M 105.39648,14 h -1.10156 V 7.4550781 h 1.10156 z" />
    <path
       id="path2452-8"
       d="m 110.98633,13.941406 q -0.31055,0.08203 -0.67969,0.134766 -0.36328,0.05273 -0.65039,0.05273 -1.00195,0 -1.52344,-0.539062 -0.52148,-0.539063 -0.52148,-1.728516 V 8.3808594 h -0.74414 V 7.4550781 h 0.74414 V 5.5742187 h 1.10156 v 1.8808594 h 2.27344 v 0.9257813 h -2.27344 v 2.9824216 q 0,0.515625 0.0234,0.808594 0.0234,0.287109 0.16406,0.539063 0.12891,0.234375 0.35156,0.345703 0.22852,0.105468 0.69141,0.105468 0.26953,0 0.5625,-0.07617 0.29297,-0.08203 0.42187,-0.134766 h 0.0586 z" />
    <path
       id="path2454-7"
       d="m 117.79492,14 h -1.10156 v -3.726562 q 0,-0.4511724 -0.0527,-0.8437505 Q 116.58789,9.03125 116.44727,8.8085938 116.30078,8.5625 116.02539,8.4453125 115.75,8.3222656 115.31055,8.3222656 q -0.45117,0 -0.94336,0.2226563 -0.49219,0.2226562 -0.94336,0.5683594 V 14 h -1.10156 V 4.8828125 h 1.10156 v 3.2988281 q 0.51562,-0.4277344 1.0664,-0.6679687 0.55079,-0.2402344 1.13086,-0.2402344 1.06055,0 1.61719,0.6386719 0.55664,0.6386719 0.55664,1.8398437 z" />
  </g>
  <g
     style="font-size:12px;text-anchor:middle;stroke:none"
     id="text1418-3"
     aria-label="521-1234"
     transform="translate(418.18955,329.72145)">
    <path
       id="path2458-9"
       d="m 147.30664,11.228516 q 0,0.609375 -0.22266,1.166015 -0.22265,0.556641 -0.60937,0.9375 -0.42188,0.410157 -1.00781,0.632813 -0.58008,0.216797 -1.34766,0.216797 -0.71484,0 -1.37695,-0.152344 -0.66211,-0.146484 -1.11914,-0.357422 v -1.236328 h 0.082 q 0.48047,0.304687 1.125,0.521484 0.64453,0.210938 1.26562,0.210938 0.41602,0 0.80274,-0.117188 0.39258,-0.117187 0.69726,-0.410156 0.25782,-0.251953 0.38672,-0.603516 0.13477,-0.351562 0.13477,-0.814453 0,-0.451172 -0.15821,-0.761718 -0.15234,-0.310547 -0.42773,-0.4980474 -0.30469,-0.2226562 -0.74414,-0.3105468 -0.43359,-0.09375 -0.97266,-0.09375 -0.51562,0 -0.99609,0.070312 -0.47461,0.070312 -0.82031,0.140625 V 5.2753906 h 5.25 v 1.0253906 h -4.11914 v 2.3203126 q 0.25195,-0.023437 0.51562,-0.035156 0.26367,-0.011719 0.45703,-0.011719 0.70899,0 1.24219,0.1230468 0.5332,0.1171875 0.97852,0.421875 0.46875,0.3222657 0.72656,0.8320313 0.25781,0.5097661 0.25781,1.2773441 z" />
    <path
       id="path2460-8"
       d="m 155.01758,14 h -5.90625 v -1.224609 q 0.61523,-0.527344 1.23047,-1.054688 0.62109,-0.527344 1.15429,-1.048828 1.125,-1.0898437 1.54102,-1.7285156 0.41601,-0.6445313 0.41601,-1.3886719 0,-0.6796875 -0.45117,-1.0605469 -0.44531,-0.3867187 -1.24804,-0.3867187 -0.53321,0 -1.1543,0.1875 -0.62109,0.1875 -1.21289,0.5742187 h -0.0586 V 5.6386719 q 0.41602,-0.2050782 1.10743,-0.375 0.69726,-0.1699219 1.34765,-0.1699219 1.3418,0 2.10352,0.6503906 0.76172,0.6445313 0.76172,1.7519531 0,0.4980469 -0.12891,0.9316407 -0.12305,0.4277344 -0.36914,0.8144531 -0.22852,0.3632813 -0.53906,0.7148438 -0.30469,0.3515627 -0.74414,0.7792967 -0.62696,0.615235 -1.29492,1.195313 -0.66797,0.574218 -1.24805,1.066406 h 4.69336 z" />
    <path
       id="path2462-2"
       d="m 162.16016,14 h -4.72266 v -0.890625 h 1.81641 V 7.2617187 h -1.81641 v -0.796875 q 0.36914,0 0.79102,-0.058594 0.42187,-0.064453 0.63867,-0.1816406 0.26953,-0.1464844 0.42187,-0.3691407 0.15821,-0.2285156 0.18164,-0.609375 h 0.90821 v 7.8632816 h 1.78125 z" />
    <path
       id="path2464-5"
       d="M 168.00195,10.712891 H 164.3457 V 9.6523438 h 3.65625 z" />
    <path
       id="path2466-5"
       d="m 175.26172,14 h -4.72266 v -0.890625 h 1.81641 V 7.2617187 h -1.81641 v -0.796875 q 0.36914,0 0.79102,-0.058594 0.42187,-0.064453 0.63867,-0.1816406 0.26953,-0.1464844 0.42187,-0.3691407 0.15821,-0.2285156 0.18165,-0.609375 h 0.9082 v 7.8632816 h 1.78125 z" />
    <path
       id="path2468-0"
       d="m 183.40039,14 h -5.90625 v -1.224609 q 0.61523,-0.527344 1.23047,-1.054688 0.62109,-0.527344 1.1543,-1.048828 1.125,-1.0898437 1.54101,-1.7285156 0.41602,-0.6445313 0.41602,-1.3886719 0,-0.6796875 -0.45117,-1.0605469 -0.44532,-0.3867187 -1.24805,-0.3867187 -0.5332,0 -1.1543,0.1875 -0.62109,0.1875 -1.21289,0.5742187 h -0.0586 V 5.6386719 q 0.41601,-0.2050782 1.10742,-0.375 0.69726,-0.1699219 1.34766,-0.1699219 1.34179,0 2.10351,0.6503906 0.76172,0.6445313 0.76172,1.7519531 0,0.4980469 -0.12891,0.9316407 -0.12304,0.4277344 -0.36914,0.8144531 -0.22851,0.3632813 -0.53906,0.7148438 -0.30469,0.3515627 -0.74414,0.7792967 -0.62695,0.615235 -1.29492,1.195313 -0.66797,0.574218 -1.24805,1.066406 h 4.69336 z" />
    <path
       id="path2470-1"
       d="m 190.27344,9.7988281 q 0.28125,0.2519529 0.46289,0.6328129 0.18164,0.380859 0.18164,0.984375 0,0.597656 -0.2168,1.095703 -0.2168,0.498047 -0.60937,0.867187 -0.43946,0.410157 -1.03711,0.609375 -0.5918,0.19336 -1.30078,0.19336 -0.72657,0 -1.42969,-0.175782 -0.70313,-0.169921 -1.1543,-0.375 V 12.40625 h 0.0879 q 0.49805,0.328125 1.17188,0.544922 0.67383,0.216797 1.30078,0.216797 0.36914,0 0.78515,-0.123047 0.41602,-0.123047 0.67383,-0.363281 0.26953,-0.257813 0.39844,-0.56836 0.13477,-0.310547 0.13477,-0.785156 0,-0.46875 -0.15235,-0.773437 -0.14648,-0.310547 -0.41015,-0.486329 -0.26368,-0.1816402 -0.63868,-0.2460934 -0.375,-0.070312 -0.80859,-0.070312 h -0.52734 V 8.7792969 h 0.41015 q 0.89063,0 1.41797,-0.3691406 0.5332,-0.375 0.5332,-1.0898438 0,-0.3164063 -0.13476,-0.5507813 -0.13477,-0.2402343 -0.375,-0.3925781 -0.25195,-0.1523437 -0.53906,-0.2109375 -0.28711,-0.058594 -0.65039,-0.058594 -0.55664,0 -1.1836,0.1992187 -0.62695,0.1992188 -1.18359,0.5625 h -0.0586 V 5.6445312 q 0.41602,-0.2050781 1.10743,-0.375 0.69726,-0.1757812 1.34765,-0.1757812 0.63867,0 1.125,0.1171875 0.48633,0.1171875 0.87891,0.375 0.42187,0.28125 0.63867,0.6796875 0.2168,0.3984375 0.2168,0.9316406 0,0.7265625 -0.51563,1.2714844 -0.50976,0.5390625 -1.20703,0.6796875 v 0.082031 q 0.28125,0.046875 0.64453,0.1992187 0.36328,0.1464844 0.61524,0.3691406 z" />
    <path
       id="path2472-2"
       d="m 198.88086,11.544922 h -1.29492 V 14 h -1.125 v -2.455078 h -4.17774 v -1.347656 l 4.22461,-4.9218754 h 1.07813 v 5.3320314 h 1.29492 z m -2.41992,-0.9375 V 6.6699219 l -3.38086,3.9375001 z" />
  </g>
  <g
     transform="translate(438.34189,269.82694)"
     id="text1526-4"
     aria-label="Sandra Dee"
     style="font-size:12px;text-anchor:middle;stroke:none">
    <path
       id="path2648-2"
       d="m 37.203125,11.509766 q 0,0.509765 -0.240234,1.007812 -0.234375,0.498047 -0.66211,0.84375 -0.46875,0.375 -1.095703,0.585938 -0.621094,0.210937 -1.5,0.210937 -0.943359,0 -1.699219,-0.175781 -0.75,-0.175781 -1.529297,-0.521484 v -1.453125 h 0.08203 q 0.662109,0.550781 1.529297,0.849609 0.867187,0.298828 1.628906,0.298828 1.078125,0 1.675781,-0.404297 0.603516,-0.404297 0.603516,-1.078125 0,-0.580078 -0.28711,-0.855469 -0.28125,-0.27539 -0.861328,-0.427734 -0.439453,-0.117187 -0.955078,-0.193359 -0.509766,-0.07617 -1.083984,-0.19336 -1.160157,-0.2460935 -1.722657,-0.8378904 -0.55664,-0.5976562 -0.55664,-1.5527344 0,-1.0957031 0.925781,-1.7929687 0.925781,-0.703125 2.349609,-0.703125 0.919922,0 1.6875,0.1757812 0.767579,0.1757813 1.359375,0.4335938 v 1.3710937 h -0.08203 q -0.498047,-0.421875 -1.3125,-0.6972656 -0.808594,-0.28125 -1.658203,-0.28125 -0.931641,0 -1.5,0.3867188 -0.5625,0.3867187 -0.5625,0.9960937 0,0.5449219 0.28125,0.8554688 0.28125,0.3105469 0.990234,0.4746094 0.375,0.082031 1.066407,0.1992187 0.691406,0.1171875 1.171875,0.2402344 0.972656,0.2578125 1.464843,0.7792966 0.492188,0.521485 0.492188,1.458985 z" />
    <path
       id="path2650-8"
       d="M 44.064453,14 H 42.96875 v -0.697266 q -0.146484,0.09961 -0.398438,0.28125 -0.246093,0.175782 -0.480468,0.28125 Q 41.814453,14 41.457031,14.087891 q -0.357422,0.09375 -0.83789,0.09375 -0.884766,0 -1.5,-0.585938 -0.615235,-0.585937 -0.615235,-1.49414 0,-0.744141 0.316406,-1.201172 0.322266,-0.462891 0.914063,-0.726563 0.597656,-0.2636717 1.435547,-0.3574217 0.83789,-0.09375 1.798828,-0.140625 V 9.5058594 q 0,-0.375 -0.134766,-0.6210938 -0.128906,-0.2460937 -0.375,-0.3867187 -0.234375,-0.1347656 -0.5625,-0.1816406 -0.328125,-0.046875 -0.685547,-0.046875 -0.433593,0 -0.966796,0.1171875 -0.533204,0.1113281 -1.101563,0.328125 h -0.05859 V 7.5957031 Q 39.40625,7.5078125 40.015625,7.4023437 40.625,7.296875 41.216797,7.296875 q 0.691406,0 1.201172,0.1171875 0.515625,0.1113281 0.890625,0.3867187 0.36914,0.2695313 0.5625,0.6972657 0.193359,0.4277344 0.193359,1.0605469 z M 42.96875,12.388672 v -1.822266 q -0.503906,0.0293 -1.189453,0.08789 -0.679688,0.05859 -1.078125,0.169922 -0.47461,0.134765 -0.767578,0.421875 -0.292969,0.28125 -0.292969,0.779297 0,0.5625 0.339844,0.849609 0.339843,0.28125 1.037109,0.28125 0.580078,0 1.060547,-0.222656 0.480469,-0.228516 0.890625,-0.544922 z" />
    <path
       id="path2652-9"
       d="m 51.669922,14 h -1.101563 v -3.726562 q 0,-0.4511724 -0.05273,-0.8437505 Q 50.462891,9.03125 50.322266,8.8085938 50.175781,8.5625 49.900391,8.4453125 49.625,8.3222656 49.185547,8.3222656 q -0.451172,0 -0.94336,0.2226563 Q 47.75,8.7675781 47.298828,9.1132813 V 14 H 46.197266 V 7.4550781 h 1.101562 v 0.7265625 q 0.515625,-0.4277344 1.066406,-0.6679687 0.550782,-0.2402344 1.13086,-0.2402344 1.060547,0 1.617187,0.6386719 0.556641,0.6386719 0.556641,1.8398437 z" />
    <path
       id="path2654-9"
       d="m 59.099609,14 h -1.101562 v -0.685547 q -0.47461,0.410156 -0.990235,0.638672 -0.515625,0.228516 -1.11914,0.228516 -1.171875,0 -1.863281,-0.902344 -0.685547,-0.902344 -0.685547,-2.501953 0,-0.8320315 0.234375,-1.4824221 0.240234,-0.6503906 0.644531,-1.1074219 0.398437,-0.4453125 0.925781,-0.6796875 0.533203,-0.234375 1.101563,-0.234375 0.515625,0 0.914062,0.1113281 0.398438,0.1054688 0.837891,0.3339844 V 4.8828125 h 1.101562 z M 57.998047,12.388672 V 8.6328125 Q 57.552734,8.4335938 57.201172,8.3574219 56.849609,8.28125 56.433594,8.28125 q -0.925782,0 -1.441407,0.6445313 -0.515625,0.6445312 -0.515625,1.8281247 0,1.166016 0.398438,1.775391 0.398437,0.603516 1.277344,0.603516 0.46875,0 0.949218,-0.205079 0.480469,-0.210937 0.896485,-0.539062 z" />
    <path
       id="path2656-9"
       d="m 65.351562,8.65625 h -0.05859 Q 65.046878,8.597656 64.812503,8.574219 64.583987,8.544922 64.267581,8.544922 q -0.509766,0 -0.984375,0.2285156 -0.474609,0.2226563 -0.914062,0.5800781 V 14 H 61.267578 V 7.4550781 h 1.101563 V 8.421875 q 0.65625,-0.5273438 1.154296,-0.7441406 0.503907,-0.2226563 1.025391,-0.2226563 0.287109,0 0.416016,0.017578 0.128906,0.011719 0.386718,0.052734 z" />
    <path
       id="path2658-7"
       d="m 71.486328,14 h -1.095703 v -0.697266 q -0.146484,0.09961 -0.398438,0.28125 -0.246093,0.175782 -0.480468,0.28125 Q 69.236328,14 68.878906,14.087891 q -0.357422,0.09375 -0.83789,0.09375 -0.884766,0 -1.5,-0.585938 -0.615235,-0.585937 -0.615235,-1.49414 0,-0.744141 0.316406,-1.201172 0.322266,-0.462891 0.914063,-0.726563 0.597656,-0.2636717 1.435547,-0.3574217 0.83789,-0.09375 1.798828,-0.140625 V 9.5058594 q 0,-0.375 -0.134766,-0.6210938 -0.128906,-0.2460937 -0.375,-0.3867187 -0.234375,-0.1347656 -0.5625,-0.1816406 -0.328125,-0.046875 -0.685547,-0.046875 -0.433593,0 -0.966796,0.1171875 -0.533204,0.1113281 -1.101563,0.328125 h -0.05859 V 7.5957031 Q 66.828125,7.5078125 67.4375,7.4023437 68.046875,7.296875 68.638672,7.296875 q 0.691406,0 1.201172,0.1171875 0.515625,0.1113281 0.890625,0.3867187 0.36914,0.2695313 0.5625,0.6972657 0.193359,0.4277344 0.193359,1.0605469 z m -1.095703,-1.611328 v -1.822266 q -0.503906,0.0293 -1.189453,0.08789 -0.679688,0.05859 -1.078125,0.169922 -0.47461,0.134765 -0.767578,0.421875 -0.292969,0.28125 -0.292969,0.779297 0,0.5625 0.339844,0.849609 0.339843,0.28125 1.037109,0.28125 0.580078,0 1.060547,-0.222656 0.480469,-0.228516 0.890625,-0.544922 z" />
    <path
       id="path2660-7"
       d="m 85.296875,9.6464844 q 0,1.1894536 -0.521484,2.1562496 -0.515625,0.966797 -1.376954,1.5 Q 82.800781,13.671875 82.0625,13.835938 81.330078,14 80.128906,14 H 77.925781 V 5.2753906 h 2.179688 q 1.277343,0 2.027343,0.1875 0.75586,0.1816406 1.277344,0.5039063 0.890625,0.5566406 1.388672,1.4824218 0.498047,0.9257813 0.498047,2.1972657 z m -1.212891,-0.017578 q 0,-1.0253907 -0.357422,-1.7285157 Q 83.369141,7.1972656 82.660156,6.7929687 82.144531,6.5 81.564453,6.3886719 80.984375,6.2714844 80.175781,6.2714844 h -1.089844 v 6.7324216 h 1.089844 q 0.837891,0 1.458985,-0.123047 0.626953,-0.123046 1.148437,-0.457031 0.650391,-0.416015 0.972656,-1.095703 0.328125,-0.679687 0.328125,-1.6992186 z" />
    <path
       id="path2662-2"
       d="m 92.574219,10.841797 h -4.822266 q 0,0.603516 0.181641,1.054687 0.18164,0.445313 0.498047,0.732422 0.304687,0.28125 0.720703,0.421875 0.421875,0.140625 0.925781,0.140625 0.667969,0 1.341797,-0.263672 0.679687,-0.269531 0.966797,-0.527343 h 0.05859 v 1.201172 q -0.55664,0.234375 -1.136718,0.392578 -0.580078,0.158203 -1.21875,0.158203 -1.628907,0 -2.542969,-0.878906 -0.914063,-0.884766 -0.914063,-2.507813 0,-1.6054687 0.873047,-2.5488281 0.878907,-0.9433594 2.308594,-0.9433594 1.324219,0 2.039063,0.7734375 0.720703,0.7734375 0.720703,2.197266 z M 91.501953,9.9980469 Q 91.496094,9.1308594 91.0625,8.65625 90.634766,8.1816406 89.755859,8.1816406 q -0.884765,0 -1.412109,0.5214844 -0.521484,0.5214844 -0.591797,1.2949219 z" />
    <path
       id="path2664-2"
       d="m 99.722656,10.841797 h -4.822265 q 0,0.603516 0.18164,1.054687 0.181641,0.445313 0.498047,0.732422 0.304688,0.28125 0.720703,0.421875 0.421875,0.140625 0.925781,0.140625 0.667969,0 1.341797,-0.263672 0.679688,-0.269531 0.966797,-0.527343 h 0.05859 v 1.201172 q -0.556641,0.234375 -1.136719,0.392578 -0.580078,0.158203 -1.21875,0.158203 -1.628906,0 -2.542969,-0.878906 -0.914062,-0.884766 -0.914062,-2.507813 0,-1.6054687 0.873047,-2.5488281 0.878906,-0.9433594 2.308594,-0.9433594 1.324218,0 2.039062,0.7734375 0.720703,0.7734375 0.720703,2.197266 z M 98.650391,9.9980469 Q 98.644531,9.1308594 98.210937,8.65625 97.783203,8.1816406 96.904297,8.1816406 q -0.884766,0 -1.41211,0.5214844 -0.521484,0.5214844 -0.591796,1.2949219 z" />
  </g>
  <g
     transform="translate(438.32432,269.72145)"
     id="text1530-8"
     aria-label="521-9655"
     style="font-size:12px;text-anchor:middle;stroke:none">
    <path
       id="path2668-9"
       d="m 127.30664,11.228516 q 0,0.609375 -0.22266,1.166015 -0.22265,0.556641 -0.60937,0.9375 -0.42188,0.410157 -1.00781,0.632813 -0.58008,0.216797 -1.34766,0.216797 -0.71484,0 -1.37695,-0.152344 -0.66211,-0.146484 -1.11914,-0.357422 v -1.236328 h 0.082 q 0.48047,0.304687 1.125,0.521484 0.64453,0.210938 1.26562,0.210938 0.41602,0 0.80274,-0.117188 0.39258,-0.117187 0.69726,-0.410156 0.25782,-0.251953 0.38672,-0.603516 0.13477,-0.351562 0.13477,-0.814453 0,-0.451172 -0.15821,-0.761718 -0.15234,-0.310547 -0.42773,-0.4980474 -0.30469,-0.2226562 -0.74414,-0.3105468 -0.43359,-0.09375 -0.97266,-0.09375 -0.51562,0 -0.99609,0.070312 -0.47461,0.070312 -0.82031,0.140625 V 5.2753906 h 5.25 v 1.0253906 h -4.11914 v 2.3203126 q 0.25195,-0.023437 0.51562,-0.035156 0.26367,-0.011719 0.45703,-0.011719 0.70899,0 1.24219,0.1230468 0.5332,0.1171875 0.97852,0.421875 0.46875,0.3222657 0.72656,0.8320313 0.25781,0.5097661 0.25781,1.2773441 z" />
    <path
       id="path2670-1"
       d="m 135.01758,14 h -5.90625 v -1.224609 q 0.61523,-0.527344 1.23047,-1.054688 0.62109,-0.527344 1.15429,-1.048828 1.125,-1.0898437 1.54102,-1.7285156 0.41601,-0.6445313 0.41601,-1.3886719 0,-0.6796875 -0.45117,-1.0605469 -0.44531,-0.3867187 -1.24804,-0.3867187 -0.53321,0 -1.1543,0.1875 -0.62109,0.1875 -1.21289,0.5742187 h -0.0586 V 5.6386719 q 0.41602,-0.2050782 1.10743,-0.375 0.69726,-0.1699219 1.34765,-0.1699219 1.3418,0 2.10352,0.6503906 0.76172,0.6445313 0.76172,1.7519531 0,0.4980469 -0.12891,0.9316407 -0.12305,0.4277344 -0.36914,0.8144531 -0.22852,0.3632813 -0.53906,0.7148438 -0.30469,0.3515627 -0.74414,0.7792967 -0.62696,0.615235 -1.29492,1.195313 -0.66797,0.574218 -1.24805,1.066406 h 4.69336 z" />
    <path
       id="path2672-0"
       d="m 142.16016,14 h -4.72266 v -0.890625 h 1.81641 V 7.2617187 h -1.81641 v -0.796875 q 0.36914,0 0.79102,-0.058594 0.42187,-0.064453 0.63867,-0.1816406 0.26953,-0.1464844 0.42187,-0.3691407 0.15821,-0.2285156 0.18164,-0.609375 h 0.90821 v 7.8632816 h 1.78125 z" />
    <path
       id="path2674-8"
       d="M 148.00195,10.712891 H 144.3457 V 9.6523438 h 3.65625 z" />
    <path
       id="path2676-5"
       d="m 155.74805,9.1132813 q 0,1.1425777 -0.26368,2.0742187 -0.25781,0.931641 -0.78515,1.587891 -0.5332,0.667968 -1.33594,1.03125 -0.80273,0.363281 -1.88672,0.363281 -0.30469,0 -0.57422,-0.03516 -0.26953,-0.0293 -0.48047,-0.09961 v -1.11914 h 0.0586 q 0.16992,0.08789 0.48047,0.169922 0.31054,0.07617 0.6914,0.07617 1.29493,0 2.02735,-0.773437 0.73828,-0.779297 0.85547,-2.144531 -0.54493,0.328125 -1.02539,0.46875 -0.48047,0.140625 -1.04883,0.140625 -0.53907,0 -0.97852,-0.105469 -0.43359,-0.105469 -0.87305,-0.410156 -0.51562,-0.3574222 -0.77929,-0.9082035 -0.25781,-0.5507812 -0.25781,-1.3183594 0,-1.3359375 0.8789,-2.1738281 0.87891,-0.8378906 2.14453,-0.8378906 0.63282,0 1.17188,0.1992187 0.53906,0.1933594 0.94336,0.5859375 0.49804,0.4863281 0.76758,1.2539063 0.26953,0.7617187 0.26953,1.9746094 z m -1.1836,-0.2519532 q 0,-0.9082031 -0.1875,-1.4589844 -0.1875,-0.5507812 -0.51562,-0.8554687 -0.27539,-0.2636719 -0.5918,-0.375 -0.31641,-0.1171875 -0.68555,-0.1171875 -0.84375,0 -1.33593,0.5273437 -0.48633,0.5273438 -0.48633,1.4824219 0,0.5566407 0.1582,0.9082032 0.1582,0.3515625 0.5332,0.6152343 0.26368,0.1816407 0.58008,0.2460938 0.31641,0.058594 0.70313,0.058594 0.45703,0 0.92578,-0.1230468 0.46875,-0.1230469 0.87891,-0.3574219 0.006,-0.1230469 0.0117,-0.2402344 0.0117,-0.1230469 0.0117,-0.3105469 z" />
    <path
       id="path2678-7"
       d="m 163.5293,11.169922 q 0,1.330078 -0.87891,2.173828 -0.87305,0.837891 -2.14453,0.837891 -0.64453,0 -1.17188,-0.199219 -0.52734,-0.199219 -0.93164,-0.591797 -0.5039,-0.486328 -0.77929,-1.289062 -0.26953,-0.802735 -0.26953,-1.933594 0,-1.1601565 0.24609,-2.0566409 0.25195,-0.8964844 0.79687,-1.59375 0.51563,-0.6621094 1.33008,-1.03125 0.81446,-0.375 1.89844,-0.375 0.3457,0 0.58008,0.029297 0.23437,0.029297 0.47461,0.1054687 v 1.1191407 h -0.0586 q -0.16406,-0.087891 -0.49804,-0.1640625 -0.32813,-0.082031 -0.67383,-0.082031 -1.25977,0 -2.00977,0.7910156 -0.75,0.7851563 -0.87304,2.1269532 0.49218,-0.2988281 0.96679,-0.4511719 0.48047,-0.1582031 1.10742,-0.1582031 0.55665,0 0.97852,0.1054687 0.42773,0.099609 0.87305,0.4101563 0.51562,0.3574219 0.77343,0.9023437 0.26368,0.5449215 0.26368,1.3242185 z m -1.18946,0.04687 q 0,-0.544922 -0.16406,-0.902344 -0.1582,-0.3574217 -0.52734,-0.6210936 -0.26953,-0.1875 -0.59766,-0.2460938 -0.32812,-0.058594 -0.68555,-0.058594 -0.49804,0 -0.92578,0.1171875 -0.42773,0.1171875 -0.8789,0.3632812 -0.0117,0.1289063 -0.0176,0.2519537 -0.006,0.117187 -0.006,0.298828 0,0.925781 0.1875,1.464844 0.19336,0.533203 0.52734,0.84375 0.26953,0.257812 0.58008,0.380859 0.31641,0.117188 0.68555,0.117188 0.84961,0 1.33594,-0.515625 0.48632,-0.521485 0.48632,-1.494141 z" />
    <path
       id="path2680-7"
       d="m 170.9707,11.228516 q 0,0.609375 -0.22265,1.166015 -0.22266,0.556641 -0.60938,0.9375 -0.42187,0.410157 -1.00781,0.632813 -0.58008,0.216797 -1.34766,0.216797 -0.71484,0 -1.37695,-0.152344 -0.66211,-0.146484 -1.11914,-0.357422 v -1.236328 h 0.082 q 0.48047,0.304687 1.125,0.521484 0.64453,0.210938 1.26563,0.210938 0.41601,0 0.80273,-0.117188 0.39258,-0.117187 0.69727,-0.410156 0.25781,-0.251953 0.38671,-0.603516 0.13477,-0.351562 0.13477,-0.814453 0,-0.451172 -0.1582,-0.761718 -0.15235,-0.310547 -0.42774,-0.4980474 -0.30469,-0.2226562 -0.74414,-0.3105468 -0.43359,-0.09375 -0.97265,-0.09375 -0.51563,0 -0.9961,0.070312 -0.47461,0.070312 -0.82031,0.140625 V 5.2753906 h 5.25 v 1.0253906 h -4.11914 v 2.3203126 q 0.25195,-0.023437 0.51562,-0.035156 0.26368,-0.011719 0.45703,-0.011719 0.70899,0 1.24219,0.1230468 0.53321,0.1171875 0.97852,0.421875 0.46875,0.3222657 0.72656,0.8320313 0.25781,0.5097661 0.25781,1.2773441 z" />
    <path
       id="path2682-2"
       d="m 178.61133,11.228516 q 0,0.609375 -0.22266,1.166015 -0.22265,0.556641 -0.60937,0.9375 -0.42188,0.410157 -1.00782,0.632813 -0.58007,0.216797 -1.34765,0.216797 -0.71485,0 -1.37696,-0.152344 -0.6621,-0.146484 -1.11914,-0.357422 v -1.236328 h 0.082 q 0.48046,0.304687 1.125,0.521484 0.64453,0.210938 1.26562,0.210938 0.41602,0 0.80273,-0.117188 0.39258,-0.117187 0.69727,-0.410156 0.25781,-0.251953 0.38672,-0.603516 0.13476,-0.351562 0.13476,-0.814453 0,-0.451172 -0.1582,-0.761718 -0.15234,-0.310547 -0.42773,-0.4980474 -0.30469,-0.2226562 -0.74414,-0.3105468 -0.4336,-0.09375 -0.97266,-0.09375 -0.51562,0 -0.99609,0.070312 -0.47461,0.070312 -0.82032,0.140625 V 5.2753906 h 5.25 v 1.0253906 h -4.11914 v 2.3203126 q 0.25196,-0.023437 0.51563,-0.035156 0.26367,-0.011719 0.45703,-0.011719 0.70898,0 1.24219,0.1230468 0.5332,0.1171875 0.97851,0.421875 0.46875,0.3222657 0.72657,0.8320313 0.25781,0.5097661 0.25781,1.2773441 z" />
  </g>
  <path
     id="path5408"
     style="font-size:12px;text-anchor:middle;fill:#a8a8ff;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     d="m 262.4411,269.35916 h 79.99956 v 20.00001 H 262.4411 Z" />
  <path
     id="path5410"
     style="font-size:12px;text-anchor:middle;fill:#a8a8ff;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     d="m 262.4411,289.35917 h 79.99956 v 20.00001 H 262.4411 Z" />
  <path
     id="path5412"
     style="font-size:12px;text-anchor:middle;fill:#a8a8ff;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     d="m 262.4411,309.35918 h 79.99956 v 19.99998 H 262.4411 Z" />
  <path
     id="path5414"
     style="font-size:12px;text-anchor:middle;fill:#a8a8ff;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     d="m 262.4411,329.35916 h 79.99956 v 20.00001 H 262.4411 Z" />
  <path
     id="path5416"
     style="font-size:12px;text-anchor:middle;fill:#a8a8ff;fill-opacity:1;stroke:#000000;stroke-width:0.999999"
     d="m 262.4411,349.35917 h 79.99956 v 20.00002 H 262.4411 Z" />
  <text
     xml:space="preserve"
     id="text5460"
     style="font-size:4.23332999999999959px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';white-space:pre;shape-inside:url(#rect5462);"
     transform="matrix(3.7795276,0,0,3.7795276,154.42265,-87.571312)"><tspan
       x="33.740234"
       y="109.20595"><tspan>5123</tspan></tspan></text>
  <path
     id="path6110"
     style="font-size:12px;text-anchor:middle;stroke:#dd0000;stroke-width:1.50832;marker-end:url(#arrowtip_C-8)"
     d="m 370.45633,280.03634 h 45.50041" />
  <path
     d="m 370.45633,340.03634 h 45.50041"
     style="font-size:12px;text-anchor:middle;stroke:#dd0000;stroke-width:1.50832;marker-end:url(#arrowtip_C-8)"
     id="path6112" />
  <path
     id="path6114"
     style="font-size:12px;text-anchor:middle;stroke:#dd0000"
     d="m 345.129,319.43148 h 5" />
  <path
     id="path6116"
     style="font-size:12px;text-anchor:middle;stroke:#dd0000;stroke-width:0.730661"
     d="m 350.129,319.43148 20.32733,-39.39514" />
  <path
     id="path6118"
     style="font-size:12px;text-anchor:middle;stroke:#dd0000;stroke-width:1;stroke-miterlimit:4;stroke-dasharray:none"
     d="m 350.129,319.43148 20.32733,20.60486" />
  <text
     transform="matrix(3.7795276,0,0,3.7795276,154.86797,-107.43504)"
     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.23332999999999959px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect6030);"
     id="text6028"
     xml:space="preserve"><tspan
       x="33.740234"
       y="109.20595"><tspan>6161</tspan></tspan></text>
  <g
     transform="translate(418.37412,290.56807)"
     id="g6066"
     aria-label="Lisa Smith"
     style="font-size:12px;text-anchor:middle;stroke:none">
    <path
       id="path6048"
       d="M 60.097656,14 H 54.578125 V 5.2753906 h 1.160156 V 12.96875 h 4.359375 z" />
    <path
       id="path6050"
       d="M 62.353516,6.359375 H 61.111328 V 5.2167969 h 1.242188 z M 62.283203,14 H 61.181641 V 7.4550781 h 1.101562 z" />
    <path
       id="path6052"
       d="m 69.150391,12.113281 q 0,0.896485 -0.744141,1.470703 -0.738281,0.574219 -2.021484,0.574219 -0.726563,0 -1.335938,-0.169922 -0.603516,-0.175781 -1.013672,-0.380859 v -1.236328 h 0.05859 q 0.521484,0.392578 1.160156,0.626953 0.638672,0.228516 1.22461,0.228516 0.726562,0 1.136718,-0.234375 0.410157,-0.234375 0.410157,-0.738282 0,-0.386718 -0.222657,-0.585937 -0.222656,-0.199219 -0.855468,-0.339844 -0.234375,-0.05273 -0.615235,-0.123047 -0.375,-0.07031 -0.685547,-0.152344 -0.861328,-0.228515 -1.224609,-0.667968 -0.357422,-0.4453129 -0.357422,-1.0898441 0,-0.4042969 0.164063,-0.7617188 0.169921,-0.3574218 0.509765,-0.6386719 0.328125,-0.2753906 0.832031,-0.4335937 0.509766,-0.1640625 1.136719,-0.1640625 0.585938,0 1.183594,0.1464844 0.603516,0.140625 1.001953,0.3457031 v 1.1777344 h -0.05859 Q 68.412109,8.65625 67.808594,8.4453125 67.205078,8.2285156 66.625,8.2285156 q -0.603516,0 -1.019531,0.234375 -0.416016,0.2285157 -0.416016,0.6855469 0,0.4042969 0.251953,0.609375 0.246094,0.2050781 0.796875,0.3339845 0.304688,0.07031 0.679688,0.140625 0.380859,0.07031 0.632812,0.128906 0.767578,0.175781 1.183594,0.603516 0.416016,0.433594 0.416016,1.148437 z" />
    <path
       id="path6054"
       d="m 75.818359,14 h -1.095703 v -0.697266 q -0.146484,0.09961 -0.398437,0.28125 -0.246094,0.175782 -0.480469,0.28125 Q 73.568359,14 73.210937,14.087891 q -0.357421,0.09375 -0.83789,0.09375 -0.884766,0 -1.5,-0.585938 -0.615235,-0.585937 -0.615235,-1.49414 0,-0.744141 0.316407,-1.201172 0.322265,-0.462891 0.914062,-0.726563 0.597656,-0.2636717 1.435547,-0.3574217 0.837891,-0.09375 1.798828,-0.140625 V 9.5058594 q 0,-0.375 -0.134765,-0.6210938 -0.128907,-0.2460937 -0.375,-0.3867187 -0.234375,-0.1347656 -0.5625,-0.1816406 -0.328125,-0.046875 -0.685547,-0.046875 -0.433594,0 -0.966797,0.1171875 -0.533203,0.1113281 -1.101563,0.328125 h -0.05859 V 7.5957031 q 0.322265,-0.087891 0.93164,-0.1933594 0.609375,-0.1054687 1.201172,-0.1054687 0.691406,0 1.201172,0.1171875 0.515625,0.1113281 0.890625,0.3867187 0.369141,0.2695313 0.5625,0.6972657 0.193359,0.4277344 0.193359,1.0605469 z m -1.095703,-1.611328 v -1.822266 q -0.503906,0.0293 -1.189453,0.08789 -0.679687,0.05859 -1.078125,0.169922 -0.474609,0.134765 -0.767578,0.421875 -0.292969,0.28125 -0.292969,0.779297 0,0.5625 0.339844,0.849609 0.339844,0.28125 1.037109,0.28125 0.580078,0 1.060547,-0.222656 0.480469,-0.228516 0.890625,-0.544922 z" />
    <path
       id="path6056"
       d="m 88.597656,11.509766 q 0,0.509765 -0.240234,1.007812 -0.234375,0.498047 -0.66211,0.84375 -0.46875,0.375 -1.095703,0.585938 -0.621093,0.210937 -1.5,0.210937 -0.943359,0 -1.699218,-0.175781 -0.75,-0.175781 -1.529297,-0.521484 v -1.453125 h 0.08203 q 0.662109,0.550781 1.529297,0.849609 0.867187,0.298828 1.628906,0.298828 1.078125,0 1.675781,-0.404297 0.603516,-0.404297 0.603516,-1.078125 0,-0.580078 -0.287109,-0.855469 -0.28125,-0.27539 -0.861329,-0.427734 -0.439453,-0.117187 -0.955078,-0.193359 -0.509765,-0.07617 -1.083984,-0.19336 -1.160156,-0.2460935 -1.722656,-0.8378904 -0.556641,-0.5976562 -0.556641,-1.5527344 0,-1.0957031 0.925781,-1.7929687 0.925782,-0.703125 2.34961,-0.703125 0.919922,0 1.6875,0.1757812 0.767578,0.1757813 1.359375,0.4335938 v 1.3710937 h -0.08203 q -0.498046,-0.421875 -1.3125,-0.6972656 -0.808593,-0.28125 -1.658203,-0.28125 -0.93164,0 -1.5,0.3867188 -0.5625,0.3867187 -0.5625,0.9960937 0,0.5449219 0.28125,0.8554688 0.28125,0.3105469 0.990235,0.4746094 0.375,0.082031 1.066406,0.1992187 0.691406,0.1171875 1.171875,0.2402344 0.972656,0.2578125 1.464844,0.7792966 0.492187,0.521485 0.492186,1.458985 z" />
    <path
       id="path6058"
       d="m 99.923828,14 h -1.101562 v -3.726562 q 0,-0.4218755 -0.04102,-0.8144536 Q 98.746094,9.0664063 98.623047,8.8320313 98.488281,8.5800781 98.236328,8.4511719 97.984375,8.3222656 97.509766,8.3222656 q -0.462891,0 -0.925782,0.234375 -0.46289,0.2285157 -0.925781,0.5859375 0.01758,0.1347657 0.0293,0.3164063 0.01172,0.1757812 0.01172,0.3515625 V 14 H 94.59766 v -3.726562 q 0,-0.4335942 -0.04102,-0.820313 -0.03516,-0.3925781 -0.158204,-0.6269531 -0.134765,-0.2519531 -0.386718,-0.375 -0.251953,-0.1289063 -0.726563,-0.1289063 -0.451172,0 -0.908203,0.2226563 -0.451172,0.2226562 -0.902344,0.5683594 V 14 H 90.373047 V 7.4550781 h 1.101562 V 8.1816406 Q 91.990234,7.7539062 92.5,7.5136719 q 0.515625,-0.2402344 1.095703,-0.2402344 0.667969,0 1.130859,0.28125 0.46875,0.28125 0.697266,0.7792969 0.667969,-0.5625 1.21875,-0.8085938 0.550781,-0.2519531 1.177734,-0.2519531 1.078125,0 1.587891,0.65625 0.515625,0.6503906 0.515625,1.8222656 z" />
    <path
       id="path6060"
       d="m 103.22852,6.359375 h -1.24219 V 5.2167969 h 1.24219 z M 103.1582,14 h -1.10156 V 7.4550781 h 1.10156 z" />
    <path
       id="path6062"
       d="m 108.74805,13.941406 q -0.31055,0.08203 -0.67969,0.134766 -0.36328,0.05273 -0.65039,0.05273 -1.00195,0 -1.52344,-0.539062 -0.52148,-0.539063 -0.52148,-1.728516 V 8.3808594 h -0.74414 V 7.4550781 h 0.74414 V 5.5742187 h 1.10156 v 1.8808594 h 2.27344 v 0.9257813 h -2.27344 v 2.9824216 q 0,0.515625 0.0234,0.808594 0.0234,0.287109 0.16406,0.539063 0.12891,0.234375 0.35156,0.345703 0.22852,0.105468 0.69141,0.105468 0.26953,0 0.5625,-0.07617 0.29297,-0.08203 0.42187,-0.134766 h 0.0586 z" />
    <path
       id="path6064"
       d="m 115.55664,14 h -1.10156 v -3.726562 q 0,-0.4511724 -0.0527,-0.8437505 -0.0528,-0.3984375 -0.1934,-0.6210937 -0.14648,-0.2460938 -0.42187,-0.3632813 -0.27539,-0.1230469 -0.71484,-0.1230469 -0.45118,0 -0.94336,0.2226563 -0.49219,0.2226562 -0.94336,0.5683594 V 14 h -1.10157 V 4.8828125 h 1.10157 v 3.2988281 q 0.51562,-0.4277344 1.0664,-0.6679687 0.55078,-0.2402344 1.13086,-0.2402344 1.06055,0 1.61719,0.6386719 0.55664,0.6386719 0.55664,1.8398437 z" />
  </g>
  <g
     transform="translate(418.22471,290.4626)"
     id="text1362-9"
     aria-label="521-8976"
     style="font-size:12px;text-anchor:middle;stroke:none">
    <path
       id="path2374-2"
       d="m 147.30664,11.228516 q 0,0.609375 -0.22266,1.166015 -0.22265,0.556641 -0.60937,0.9375 -0.42188,0.410157 -1.00781,0.632813 -0.58008,0.216797 -1.34766,0.216797 -0.71484,0 -1.37695,-0.152344 -0.66211,-0.146484 -1.11914,-0.357422 v -1.236328 h 0.082 q 0.48047,0.304687 1.125,0.521484 0.64453,0.210938 1.26562,0.210938 0.41602,0 0.80274,-0.117188 0.39258,-0.117187 0.69726,-0.410156 0.25782,-0.251953 0.38672,-0.603516 0.13477,-0.351562 0.13477,-0.814453 0,-0.451172 -0.15821,-0.761718 -0.15234,-0.310547 -0.42773,-0.4980474 -0.30469,-0.2226562 -0.74414,-0.3105468 -0.43359,-0.09375 -0.97266,-0.09375 -0.51562,0 -0.99609,0.070312 -0.47461,0.070312 -0.82031,0.140625 V 5.2753906 h 5.25 v 1.0253906 h -4.11914 v 2.3203126 q 0.25195,-0.023437 0.51562,-0.035156 0.26367,-0.011719 0.45703,-0.011719 0.70899,0 1.24219,0.1230468 0.5332,0.1171875 0.97852,0.421875 0.46875,0.3222657 0.72656,0.8320313 0.25781,0.5097661 0.25781,1.2773441 z" />
    <path
       id="path2376-4"
       d="m 155.01758,14 h -5.90625 v -1.224609 q 0.61523,-0.527344 1.23047,-1.054688 0.62109,-0.527344 1.15429,-1.048828 1.125,-1.0898437 1.54102,-1.7285156 0.41601,-0.6445313 0.41601,-1.3886719 0,-0.6796875 -0.45117,-1.0605469 -0.44531,-0.3867187 -1.24804,-0.3867187 -0.53321,0 -1.1543,0.1875 -0.62109,0.1875 -1.21289,0.5742187 h -0.0586 V 5.6386719 q 0.41602,-0.2050782 1.10743,-0.375 0.69726,-0.1699219 1.34765,-0.1699219 1.3418,0 2.10352,0.6503906 0.76172,0.6445313 0.76172,1.7519531 0,0.4980469 -0.12891,0.9316407 -0.12305,0.4277344 -0.36914,0.8144531 -0.22852,0.3632813 -0.53906,0.7148438 -0.30469,0.3515627 -0.74414,0.7792967 -0.62696,0.615235 -1.29492,1.195313 -0.66797,0.574218 -1.24805,1.066406 h 4.69336 z" />
    <path
       id="path2378-0"
       d="m 162.16016,14 h -4.72266 v -0.890625 h 1.81641 V 7.2617187 h -1.81641 v -0.796875 q 0.36914,0 0.79102,-0.058594 0.42187,-0.064453 0.63867,-0.1816406 0.26953,-0.1464844 0.42187,-0.3691407 0.15821,-0.2285156 0.18164,-0.609375 h 0.90821 v 7.8632816 h 1.78125 z" />
    <path
       id="path2380-3"
       d="M 168.00195,10.712891 H 164.3457 V 9.6523438 h 3.65625 z" />
    <path
       id="path2382-4"
       d="m 175.82422,11.568359 q 0,1.13086 -0.88477,1.88086 -0.8789,0.75 -2.21484,0.75 -1.41797,0 -2.26172,-0.732422 -0.83789,-0.732422 -0.83789,-1.875 0,-0.726563 0.42187,-1.3125 0.42188,-0.591797 1.18946,-0.9375001 v -0.035156 q -0.70313,-0.375 -1.04297,-0.8203125 -0.33399,-0.4453125 -0.33399,-1.1132812 0,-0.984375 0.8086,-1.640625 0.80859,-0.65625 2.05664,-0.65625 1.30664,0 2.08594,0.6269531 0.77929,0.6269531 0.77929,1.59375 0,0.5917969 -0.36914,1.1660156 -0.36914,0.5683594 -1.08398,0.890625 v 0.035156 q 0.82031,0.3515625 1.2539,0.8671871 0.4336,0.515625 0.4336,1.3125 z m -1.38867,-4.2597653 q 0,-0.6269531 -0.48633,-0.9960937 -0.48047,-0.375 -1.23047,-0.375 -0.73828,0 -1.21289,0.3515625 -0.46875,0.3515625 -0.46875,0.9492187 0,0.421875 0.23437,0.7324219 0.24024,0.3046875 0.72071,0.5449219 0.21679,0.1054688 0.62109,0.2753906 0.41016,0.1699219 0.79688,0.28125 0.58007,-0.3867187 0.80273,-0.8027343 0.22266,-0.4160157 0.22266,-0.9609376 z m 0.18164,4.3710943 q 0,-0.539063 -0.24024,-0.861329 -0.23437,-0.328125 -0.92578,-0.65625 -0.27539,-0.128906 -0.60351,-0.240234 -0.32813,-0.1113281 -0.87305,-0.3105469 -0.52734,0.2871094 -0.84961,0.7792969 -0.31641,0.492188 -0.31641,1.113281 0,0.791016 0.54493,1.306641 0.54492,0.515625 1.38281,0.515625 0.85547,0 1.36523,-0.439453 0.51563,-0.439453 0.51563,-1.207031 z" />
    <path
       id="path2384-1"
       d="m 183.38867,9.1132813 q 0,1.1425777 -0.26367,2.0742187 -0.25781,0.931641 -0.78516,1.587891 -0.5332,0.667968 -1.33593,1.03125 -0.80274,0.363281 -1.88672,0.363281 -0.30469,0 -0.57422,-0.03516 -0.26953,-0.0293 -0.48047,-0.09961 v -1.11914 h 0.0586 q 0.16993,0.08789 0.48047,0.169922 0.31055,0.07617 0.69141,0.07617 1.29492,0 2.02734,-0.773437 0.73828,-0.779297 0.85547,-2.144531 -0.54492,0.328125 -1.02539,0.46875 -0.48047,0.140625 -1.04883,0.140625 -0.53906,0 -0.97851,-0.105469 -0.4336,-0.105469 -0.87305,-0.410156 -0.51563,-0.3574222 -0.7793,-0.9082035 -0.25781,-0.5507812 -0.25781,-1.3183594 0,-1.3359375 0.87891,-2.1738281 0.8789,-0.8378906 2.14453,-0.8378906 0.63281,0 1.17187,0.1992187 0.53907,0.1933594 0.94336,0.5859375 0.49805,0.4863281 0.76758,1.2539063 0.26953,0.7617187 0.26953,1.9746094 z m -1.18359,-0.2519532 q 0,-0.9082031 -0.1875,-1.4589844 -0.1875,-0.5507812 -0.51563,-0.8554687 -0.27539,-0.2636719 -0.59179,-0.375 -0.31641,-0.1171875 -0.68555,-0.1171875 -0.84375,0 -1.33594,0.5273437 -0.48633,0.5273438 -0.48633,1.4824219 0,0.5566407 0.15821,0.9082032 0.1582,0.3515625 0.5332,0.6152343 0.26367,0.1816407 0.58008,0.2460938 0.3164,0.058594 0.70312,0.058594 0.45703,0 0.92578,-0.1230468 0.46875,-0.1230469 0.87891,-0.3574219 0.006,-0.1230469 0.0117,-0.2402344 0.0117,-0.1230469 0.0117,-0.3105469 z" />
    <path
       id="path2386-4"
       d="M 191.06445,6.5820312 187.11523,14 h -1.2539 l 4.20117,-7.6992188 h -4.96875 V 5.2753906 h 5.9707 z" />
    <path
       id="path2388-5"
       d="m 198.81055,11.169922 q 0,1.330078 -0.87891,2.173828 -0.87305,0.837891 -2.14453,0.837891 -0.64453,0 -1.17188,-0.199219 -0.52734,-0.199219 -0.93164,-0.591797 -0.5039,-0.486328 -0.77929,-1.289062 -0.26953,-0.802735 -0.26953,-1.933594 0,-1.1601565 0.24609,-2.0566409 0.25195,-0.8964844 0.79687,-1.59375 0.51563,-0.6621094 1.33008,-1.03125 0.81446,-0.375 1.89844,-0.375 0.3457,0 0.58008,0.029297 0.23437,0.029297 0.47461,0.1054687 v 1.1191407 h -0.0586 q -0.16406,-0.087891 -0.49804,-0.1640625 -0.32813,-0.082031 -0.67383,-0.082031 -1.25977,0 -2.00977,0.7910156 -0.75,0.7851563 -0.87304,2.1269532 0.49218,-0.2988281 0.96679,-0.4511719 0.48047,-0.1582031 1.10742,-0.1582031 0.55665,0 0.97852,0.1054687 0.42773,0.099609 0.87305,0.4101563 0.51562,0.3574219 0.77343,0.9023437 0.26368,0.5449215 0.26368,1.3242185 z m -1.18946,0.04687 q 0,-0.544922 -0.16406,-0.902344 -0.1582,-0.3574217 -0.52734,-0.6210936 -0.26953,-0.1875 -0.59766,-0.2460938 -0.32812,-0.058594 -0.68555,-0.058594 -0.49804,0 -0.92578,0.1171875 -0.42773,0.1171875 -0.8789,0.3632812 -0.0117,0.1289063 -0.0176,0.2519537 -0.006,0.117187 -0.006,0.298828 0,0.925781 0.1875,1.464844 0.19336,0.533203 0.52734,0.84375 0.26953,0.257812 0.58008,0.380859 0.31641,0.117188 0.68555,0.117188 0.84961,0 1.33594,-0.515625 0.48632,-0.521485 0.48632,-1.494141 z" />
  </g>
  <path
     id="path6124"
     style="font-size:12px;text-anchor:middle;stroke:#000000"
     d="m 345.129,299.49544 h 5" />
  <path
     d="m 370.17299,300.10028 h 46.06708"
     style="font-size:12px;text-anchor:middle;stroke:#000000;stroke-width:1.51768;marker-end:url(#arrowtip_N-9)"
     id="path6130" />
  <path
     style="fill:none;stroke:#000000;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
     d="m 350.27067,299.49544 20.044,0.60484"
     id="path6134" />
</svg>

`helper_hash("Lisa Smith", 6161) == 1`

---

## minimal perfect hash final

![final perfect hash](13_constexpr/hash_final.svg)

---

## benchmark

![frozen](13_constexpr/frozen.png)

---

## C++17 serene   `constexpr`

Sources:

- [N4487](https://wg21.link/n4487), Faisal Vali, Ville Voutilainen, Gabriel Dos Reis
  - [P0128](https://wg21.link/p0128), Ville Voutilainen & Daveed Vandevoorde
  - [Simplifying templates and `#ifdefs` with `if constexpr`](https://blog.tartanllama.xyz/if-constexpr/), Sy Brand

</div>

Note: C++17 kept making `constexpr` code less restricted and more user friendly

---

## `constexpr` lambda

```cpp
///options+=-std=c++17
constexpr auto add = [](int n, int m) {
  auto L = [=]{ return n; };
  auto R = [=]{ return m; };
  return [=]{ return L()+R(); };
};
static_assert(add(3,4)() == 7);
```

Note: starting from C++17, `static_assert` does not require a message

---

## variable templates (C++14)

Instead of

```cpp []
///hide
#include <iostream>
///unhide
#include <type_traits>

template <typename T>
struct is_float {
  static constexpr bool value = std::is_same<T, float>::value;
};

template <typename T>
void test(T t){
  if (is_float<T>::value){
    std::cout << "I'm a float\n";
  } else {
    std::cout << "I'm not a float\n";
  }
}
```

Source: [Baptiste Wicht's blog](https://baptiste-wicht.com/posts/2017/08/simplify-your-type-traits-with-c%2B%2B14-variable-templates.html)

---

## variable templates (C++14)

Write

```cpp []
///options+=-std=c++17
///hide
#include <iostream>
///unhide
#include <type_traits>

template <typename T>
constexpr bool is_float_v = std::is_same_v<T, float>;

template <typename T>
void test(T t){
  if (is_float_v<T>){
    std::cout << "I'm a float\n";
  } else {
    std::cout << "I'm not a float\n";
  }
}
```

Source: [Baptiste Wicht's blog](https://baptiste-wicht.com/posts/2017/08/simplify-your-type-traits-with-c%2B%2B14-variable-templates.html)

---

## variadic recursion

```cpp
template <class T> 
void f(T&& t) {
  // handle one T
}

template <class T, class... Rest> 
void f(T&& t, Rest&&... r) {
  f(t); 
  // handle the tail
  f(r...); // should I have a zero-param overload?
}
```

Note: C++17 introduces another `constexpr` related feature which attempts to solve the following annoying problems.

---

## SFINAE

```cpp
///options+=-std=c++17
///hide
#include <type_traits>
#include <memory>

///unhide
template <class T, class... Args> 
std::enable_if_t<std::is_constructible_v<T, Args...>, std::unique_ptr<T>> 
optionalFactory(Args&&... args) 
{
  return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}

template <class T, class... Args>  
std::enable_if_t<!std::is_constructible_v<T, Args...>, nullptr_t>
optionalFactory(Args&&... args) 
{
  return nullptr;
}
```

Note: this factory generates a unique_ptr if given the right set of arguments, otherwise it returns null.

---

## conditional compilation

```cpp
///hide
#include <cstdint>
#ifdef __APPLE__
#include <pthread.h>
#elif __linux__
#include <unistd.h>
#include <sys/syscall.h> 
#elif _WIN32
#include <processthreadsapi.h>
#endif
///unhide

auto thread_id() {
#ifdef __APPLE__
  uint64_t thisThreadId;
  pthread_threadid_np(nullptr, &thisThreadId);
  return thisThreadId;
#elif __linux__
  return syscall(__NR_gettid);
#elif _WIN32
  return GetCurrentThreadId();
#endif
}
```

---

## `constexpr if`

```cpp
///options+=-std=c++17
template <class T, class... Rest> 
void f(T&& t, Rest&&... r) {
  // handle one T 
  if constexpr (sizeof...(r)) {
    // handle the tail 
    f(r...); // no zero-param overload is needed
  }
}
```

---

## and

```cpp
///options+=-std=c++17
///hide
#include <type_traits>
#include <memory>

///unhide
using namespace std;

template <class T, class... Args> 
auto optionalFactory(Args&&... args) {
  if constexpr (is_constructible_v<T, Args...>) {
    return unique_ptr<T>(new T(forward<Args>(args)...));
  } else {
    return nullptr;
  }
}

auto x = optionalFactory<int>(1, 2, 3);
static_assert(std::is_same_v<decltype(x), nullptr_t>);
```

Note: notice that each branch returns a different type

---

## and almost

```cpp []
///options+=-std=c++17
///fails='pthread_threadid_np' was not declared in this scope
///hide
#include <cstdint>
#ifdef __APPLE__
#include <pthread.h>
#elif __linux__
#include <unistd.h>
#include <sys/syscall.h> 
#elif _WIN32
#include <processthreadsapi.h>
#endif

///unhide
enum class OS { Linux, Mac, Windows };

//Translate the macros to C++ 
// at a single point in the application
#ifdef __linux__
constexpr OS the_os = OS::Linux;
#elif __APPLE__
constexpr OS the_os = OS::Mac;
#elif __WIN32
constexpr OS the_os = OS::Windows;
#endif

auto thread_id() {
  if constexpr (the_os == OS::Mac) {
    uint64_t thisThreadId;
    pthread_threadid_np(nullptr, &thisThreadId);
    return thisThreadId;
  } else if constexpr (the_os == OS::Linux) {
    return syscall(__NR_gettid);
  } else if constexpr (the_os == OS::Windows) {
    return GetCurrentThreadId();
  }
}
```

Note: catches typos!

---

## need declarations

```cpp [13-20]
///options+=-std=c++17
///hide
#include <cstdint>
#ifdef __APPLE__
#include <pthread.h>
#elif __linux__
#include <unistd.h>
#include <sys/syscall.h> 
#elif _WIN32
#include <processthreadsapi.h>
#endif

///unhide
enum class OS { Linux, Mac, Windows };

using DWORD = uint32_t;
DWORD GetCurrentThreadId();
long syscall(long number, ...);
///hide
#ifndef __NR_gettid
///unhide
extern long __NR_gettid;
///hide
#endif
///unhide
typedef struct _opaque_pthread_t *
  __darwin_pthread_t;
typedef __darwin_pthread_t pthread_t;
int pthread_threadid_np(pthread_t thread, 
                        uint64_t *thread_id);

```

---

## more realistically

```cpp
///options+=-std=c++17
constexpr bool debug_mode = 
#ifdef NDEBUG
  false;
#else
  true;
#endif

void do_work() {
  if constexpr (debug_mode) {
    //some expensive check
  }
}
```

---

## note

```cpp
///options+=-std=c++17
///fails=static assertion failed: Must be arithmetic
///hide
#include <type_traits>

///unhide
template <typename T>
void do_something() {
  if constexpr (std::is_arithmetic_v<T>) {
    //do some maths
  }
  else {
    //invalid for all specializations
    static_assert(false, "Must be arithmetic");
  }
}
```

---

## instead

```cpp
///options+=-std=c++17
///hide
#include <type_traits>

///unhide
template <typename T>
void do_something() {
  static_assert(std::is_arithmetic_v<T>, "Must be arithmetic");
  //do some maths
}
```

---

## need that else

```cpp
///options+=-std=c++17
///fails=inconsistent deduction for auto return type: 'int' and then 'int*'
///hide
#include <type_traits>

///unhide
template <typename T>
auto get_value(T t) {
  if constexpr (std::is_pointer_v<T>)
    return *t;

return t;
}

int main() {
  int i;
  get_value(&i); // error
}
```

---

## in standard library

- more `chrono`
- `char_traits`

---

## C++20 contented   `constexpr`

Sources:

- [P2131](https://wg21.link/p2131), Thomas Köppe

</div>

---

## C++20 `constexpr` functions

can do much more!

- `new`/`delete`
- virtual function calls
- `dynamic_cast`
- uninitialized variables*

\* as long as they're initialized before being read

---

### mathematical constants (C++20)

`$$ (\sin(e)^2 + \cos(e)^2 + e^{\ln 2} + \sqrt{\pi} \frac{1}{\sqrt{\pi}} + \cosh{\pi}^2 - \sinh{\pi}^2 + \sqrt{3} \cdot \frac{1}{\sqrt{3}} \cdot \log_2{e} \cdot \ln 2 \cdot \log_{10}{e} \cdot \ln 10 \cdot \pi \cdot \frac{1}{\pi} + (\phi^2 - \phi)) \cdot (\sqrt{2} \sqrt{3})^2 $$`

```cpp
///external
///options+=-std=c++2a
///hide
#include <iostream>
#include <cmath>
///unhide
#include <numbers>

///hide
int main() {
using std::pow;
using std::sin;
using std::cos;
using std::sinh;
using std::cosh;
///unhide
using namespace std::numbers;
std::cout << "The answer is " <<
  (pow(sin(e), 2) + pow(cos(e), 2)
    + pow(e, ln2) + sqrt(pi) * inv_sqrtpi 
    + pow(cosh(pi), 2) - pow(sinh(pi), 2)
    + sqrt3 * inv_sqrt3 * log2e * ln2 
    * log10e * ln10 * pi * inv_pi 
    + (phi * phi - phi)) 
  * pow(sqrt2 * sqrt3, 2) 
  << '\n';
///hide
}
```

---

## can have custom precision

```cpp
///external
///options+=-std=c++2a
///hide
#include <iostream>
#include <iomanip>
///unhide
#include <numbers>

template<typename T>
auto precision = std::setprecision(std::numeric_limits<T>::digits10 + 1);

///hide
int main() {
///unhide
using namespace std::numbers;
std::cout << "π<float>       = " << precision<float>
          << pi_v<float> << '\n';
std::cout << "π<double>      = " << precision<double>
          << pi_v<double> << '\n';
std::cout << "π<long double> = " << precision<long double>
          << pi_v<long double> << '\n';
///hide
}
```

---

### back to `constexpr` functions

```cpp [1-4|6-14|16-24|26|28-33|35-43]
///options+=-std=c++2a
///hide
#include <numbers>
#include <limits>

///unhide
class Shape {
public:
    constexpr virtual double area() = 0;
};

class Square : public Shape {
public:
    constexpr Square(double side) : m_side{side} {}
    constexpr double area() override { 
      return m_side * m_side; 
    }
private:
    double m_side;
};

class Circle : public Shape {
public:
    constexpr Circle(double radius) : m_radius{radius} {}
    constexpr double area() override { 
      return m_radius * 2 * std::numbers::pi; 
    }
private:
    double m_radius;
};

class InfiniteShape : public Shape {};

constexpr double area(Shape& shape) {
    if (dynamic_cast<InfiniteShape*>(&shape)) {
        return std::numeric_limits<double>::infinity();
    }
    return shape.area();
}

constexpr double square(double x) {
    auto square = new Square(x);
    double res;
    res = area(*square);
    delete square;
    return res;
}

static_assert(square(4) == 16);
```

Note: memory must be freed before the function returns.
unfortunately `unique_ptr` is still not `constexpr`, but there's proposal [P2273](https://wg21.link/p2273) for it

---

## special member functions

```cpp
///options+=-std=c++2a
struct S{
  S() = default;
  S(const S&) = default;
  S(S&&) = default;
  S& operator=(const S&) = default;
  S& operator=(S&&) = default;
  ~S() = default;
};
```

Note: open C++ Insights

---

## immediate functions

```cpp [1|3|4-5]
///options+=-std=c++2a
///fails=the value of 'x' is not usable in a constant expression
consteval int sqr(int n) { return n * n; }

constexpr int r = sqr(100);  // okay
int x = 100;
int r2 = sqr(x);             // fails
```

Note: changing `sqr` to be `constexpr` will generate a run-time call

---

### cannot be called from non-immediate functions

```cpp
///options+=-std=c++2a
///fails='n' is not a constant expression
consteval int sqr(int n) { return n * n; }

consteval int sqrsqr(int n) { return sqr(sqr(n)); } // okay

constexpr int dblsqr(int n) { return 2 * sqr(n); }  // fails
```

---

## checking `constexpr`

```cpp [1-20|2-16|16-19|22-29]
///options+=-std=c++2a
///hide
#include <type_traits>
#include <cmath>
#include <iostream>

///unhide
constexpr double power(double b, int x) {
  if (std::is_constant_evaluated() 
      && !(b == 0.0 && x < 0)) {
    // A constant-evaluation context: 
    // Use a constexpr-friendly algorithm.
    if (x == 0)
      return 1.0;
    double r = 1.0, p = x > 0 ? b : 1.0 / b;
    auto u = unsigned(x > 0 ? x : -x);
    while (u != 0) {
      if (u & 1) r *= p;
      u /= 2;
      p *= p;
    }
    return r;
  } else {
    // Let the code generator figure it out.
    return std::pow(b, double(x));
  }
}
 
///hide
int main()
{
///unhide
// A constant-expression context
constexpr double kilo = power(10.0, 3);
int n = 3;
// Not a constant expression
// Equivalent to std::pow(10.0, double(n))
double mucho = power(10.0, n);

std::cout << kilo << " " << mucho << "\n";
///hide
}
```

---

## careful

```cpp
///options+=-std=c++2a
#include <type_traits>

constexpr void foo() {
  if constexpr(std::is_constant_evaluated()) {
    // always true
  }

// unrechable
}
```

---

## Static Initialization Order Fiasco

```cpp []
int quad(int n) {
  return n * n;
}

auto staticA  = quad(5); 
```

```cpp []
///noexecute
#include <iostream>

extern int staticA;
auto staticB = staticA;

int main() {
  std::cout << "staticB: " << staticB << '\n';
}
```

`source.cpp`

`main.cpp`

</div>

[0](https://wandbox.org/permlink/ONU4IxN72Cxo9Djy) or [25](https://wandbox.org/permlink/0A8N5XQfGyTLbl5V) ?

Source: [Modernes C++](https://www.modernescpp.com/index.php/c-20-static-initialization-order-fiasco)

Note: `staticB` is zero-initialized at compile-time and dynamically initialized at run-time, but there's no guaranteed order between init of `staticA` and `staticB`. You have a 50:50 chance that `staticB` is 0 or 25.

---

## solving with local static

```cpp [6-8]
int quad(int n) {
  return n * n;
}

int& staticA() {
  static auto staticA  = quad(5);
  return staticA;
}
```

```cpp [3-4]
///noexecute
#include <iostream>

int& staticA();
auto staticB = staticA();

int main() {
  std::cout << "staticB: " << staticB << '\n';
}
```

`source.cpp`

`main.cpp`

</div>

[25](https://wandbox.org/permlink/X240UBJDGDfhlWCC) and [25](https://wandbox.org/permlink/KTHBKtufJx25hDut)

---

## solving with `constinit`

```cpp [1,5]
///options+=-std=c++2a
constexpr int quad(int n) {
  return n * n;
}

constinit auto staticA = quad(5);
```

```cpp [3-4]
///noexecute
///options+=-std=c++2a
#include <iostream>

extern constinit int staticA;
auto staticB = staticA;

int main() {
  std::cout << "staticB: " << staticB << '\n';
}
```

`source.cpp`

`main.cpp`

</div>

[25](https://wandbox.org/permlink/vtBfs6nL7Os9u8bq) and [25](https://wandbox.org/permlink/0hb2JWFQWgQmuhGQ)

Note: removing `constexpr` from `quad` will fail compilation.

---

## `constinit` is not `const`

```cpp
///options+=-std=c++2a
constexpr int quad(int n) {
  return n * n;
}

constinit auto staticA = quad(5);

void setStaticA(int value) {
  staticA = value;
}
```

Note: only static and thread local storage duration variables can be declared `constinit`.

---

## in standard library

- **`string`,   `vector`**
- **`algorithms`**
-  <code>pair</code>,   <code>tuple</code>
-  <code>complex</code>   operators
-  <code>swap</code>
-  <code>chrono</code>   constants

---

## `to be continued...`

----

---

## C++17 Vocabulary Types

---

> One of the important roles of a [...] standard library is to provide vocabulary types. 
> A "vocabulary" type is a type that purports to provide a single **lingua franca**, a common language, for dealing with its domain.
>
> <cite>Arthur O'Dwyer</cite>

---

## strings

Sources:

- [N3921](https://wg21.link/n3921), Jeffrey Yasskin
- [Mastering the C++17 STL](https://www.packtpub.com/product/mastering-the-c-17-stl/9781787126824), Arthur O'Dwyer

</div>

---

## At the beginning there was `char*`

```cpp
///hide
#include <cstring>
#include <cstdio>

///unhide
char* greet(const char* name) {
  char buffer[100];
  snprintf(buffer, 100, "hello %s", name);
  return strdup(buffer);
}
```

- [ ]   Input string must be null terminated.
- [ ]   Input string cannot include embedded nulls.
- [ ]   Input length needs to be calculated linearly.
- [ ]   Caller has to deal with return value lifetime.

Note: another alternative is to take input buffer as `snprintf` and hope it is big enough

---

## use `std::string`?

```cpp
///hide
#include <string>

///unhide
std::string greet(const std::string& name) {
  using namespace std::literals;
  return "hello "s.append(name);
}
```

- [x]   simpler implementation
- [x]   knows its size
- [x]   manages its own lifetime
- [ ]   requires allocation + copy when passed a <code>char*</code>

---

## add `char*` + length overload?

```cpp
///hide
#include <string>

///unhide
std::string greet(const char* name, size_t length) {
  using namespace std::literals;
  return "hello "s.append(name, length);
}

std::string greet(const std::string& name) {
  return greet(name.c_str(), name.length());
}
```

- [ ]   requires maintaining two overloads
- [ ]   looses <code>std::string</code>'s reach API

---

## use `std::string_view`!

```cpp
///options+=-std=c++17
///hide
#include <iostream>
#include <string>
///unhide
#include <string_view>

std::string greet(std::string_view name) {
  using namespace std::literals;
  return "hello "s.append(name);
}

///hide
int main() {
///unhide
using namespace std::literals;
std::cout << greet("char array") << '\n';
std::cout << greet("std::string"s) << '\n';
std::cout << greet("std::string_view"sv) << '\n';
///hide
}
```

- [x]   no copy or allocation
- [x]   reach API

---

## even non standard strings

```cpp [2,4,9-10]
///external
///options+=-std=c++17
///libs=eastl:3_12_01
///hide
#include <iostream>
#include <string>
///unhide
#include <string_view>
#include <EASTL/string.h>

std::string greet(std::string_view name) {
  using namespace std::literals;
  return "hello "s.append(name);
}

///hide
void* operator new[](size_t size, const char* name, int flags,
                     unsigned debugFlags, const char* file, int line) {
  return new uint8_t[size];
}

int main() {
///unhide
const eastl::string str = "eastl::string";
std::cout << greet({str.data(), str.size()}) << '\n';
///hide
}
```

---

## rich API

```cpp [|7,8,11]
///options+=-std=c++17
///hide
#include <string_view>
#include <vector>

///unhide
std::vector<std::string_view> 
split(const std::string_view& str, 
      const std::string_view& delims = " ")
{
    std::vector<std::string_view> output;

for (size_t first = 0; first < str.size();) {
        const auto second = str.find_first_of(delims, first);

if (first != second)
            output.emplace_back(str.substr(first, second-first));

first = second + 1;
    }

return output;
}
```

---

## read only

```cpp
///options+=-std=c++17
///hide
#include <iostream>
#include <string_view>
#include <string>
int main()
{
///unhide
std::string str = "Exemplar";
std::string_view v = str;
std::cout << v[2] << '\n';
//  v[2] = 'y'; // Error: cannot modify through a string view
str[2] = 'y';
std::cout << v[2] << '\n';
///hide
}
```

---

## reference semantics

```cpp
///options+=-std=c++17
///hide
#include <string>
#include <string_view>

using namespace std::literals;
///unhide
std::string_view bad("a temporary string"s);
```

---

## not necessarily null-terminated

```cpp
///options+=-std=c++17
///hide
#include <string_view>
#include <cstring>

///unhide
auto string_size(std::string_view str) {
  return strlen(str.data());
}

int main() {
  char array[] = {'a', 'b', 'c'};
  return string_size({array, std::size(array)}); // oops
}
```

---

## benchmark

[![split benchmark](14_vocabulary_types/split.png)](https://quick-bench.com/q/qb8GrTTCPYthl_lyfe0C0zbqM40)

---

## What is a type?

- The set of values that can inhabit an expression
- May be finite or "infinite"
- Characterized by cardinality
- Expressions have types
- A program has a type

Source: [Using Types Effectively](https://www.youtube.com/watch?v=ojZbFIQSdl8), Ben Deane, CppCon 2016

---

## LET'S PLAY A GAME

To help us get thinking about types.

I'll tell you a type.

You tell me how many values it has.

There are no tricks: if it seems obvious, it is!

---

## LEVEL 1

How many values?

```cpp
///options+=-fpermissive
bool;
```

2 (true and false)

---

## LEVEL 1

How many values?

```cpp
///options+=-fpermissive
void;
```

---

## LEVEL 1

How many values?

```cpp
///hide
#include <cstdint>

///unhide
enum FireSwampDangers : int8_t {
  FLAME_SPURTS,
  LIGHTNING_SAND,
  ROUSES
};
```

---

## LEVEL 1

How many values?

```cpp
///hide
#include <cstdint>

///unhide
template <typename T>
struct Foo {
  T m_t;
};
```

As much as `T`

---

# END OF LEVEL 1

---

## optional

![optional](14_vocabulary_types/optional.gif)

Source: [N3672](https://wg21.link/n3672), Fernando Cacciola & Andrzej Krzemieński

---

## sentinel values

```cpp
///hide
struct Person {
  int age;
};

///unhide
int getAge(Person* person) {
  if (person) {
    return person->age;
  }
  return -1;
}
```

---

## sentinel values

```cpp
///hide
struct Account {
  int balance;
};

///unhide
int getBalance(Account* account) {
  if (account) {
    return account->balance;
  }
  return {/*WHAT?*/};
}
```

---

## output params?

```cpp
///hide
struct Account {
  int balance = 42;
};

///unhide
int getBalance(Account* account, bool& ok) {
  if (account) {
    ok = true;
    return account->balance;
  }
  ok = false;
  return 0;
}

///hide
int main() {
Account account;
///unhide
bool ok;
auto balance = getBalance(&account, ok);
if (ok) {
  // do something with balance
}
///hide
}
```

Note: 
- flag is easily ignored
- forces caller to declare another lvalue (even if they know the value is there). 
- flag and value are not coupled.
- what if there's more then one return value.

---

## `std::optional`

```cpp [1|3-8|10-12]
///options+=-std=c++17
///output=balance = 42
#include <optional>
///hide
#include <iostream>

struct Account {
  int balance = 42;
};
///unhide

std::optional<int> getBalance(Account* account) {
  if (account) {
    return account->balance;
  }
  return std::nullopt;
}

///hide
int main() {
Account account;
///unhide
if (auto balance = getBalance(&account)) {
  std::cout << "balance = " << *balance;
}
///hide
}
```

---

## 3 ways to get a value

```cpp []
///options+=-std=c++17
///hide
#include <optional>

struct Account {
  int balance = 42;
};

///unhide
std::optional<int> getBalance(Account* account);

int doGetBalance(Account& account) {
  return *getBalance(&account);
}
```

---

## 3 ways to get a value

```cpp []
///options+=-std=c++17
///hide
#include <optional>
#include <iostream>

struct Account {
  int balance = 42;
};

///unhide
std::optional<int> getBalance(Account* account);

int doGetBalance(Account& account) {
  try {
    return getBalance(&account).value();
  } catch (const std::bad_optional_access& e) {
    std::cerr << e.what() << '\n';
    return 0;
  }
}
```

---

## 3 ways to get a value

```cpp []
///options+=-std=c++17
///hide
#include <optional>

struct Account {
  int balance = 42;
};

///unhide
std::optional<int> getBalance(Account* account);

int doGetBalance(Account& account) {
  return getBalance(&account).value_or(0);
}
```

---

## a different implementation

```cpp
///options+=-std=c++17
///hide
#include <optional>

struct Account {
  int balance = 42;
};

///unhide
std::optional<int> getBalance(Account* account) {
  std::optional<int> res;
  if (account) {
    res = account->balance;
  }
  return res;
}
```

Note: `optional<T>` is always default constructible and copy/move assignable when `T` is

---

## lazy loading

```cpp
///options+=-std=c++17
///hide
#include <optional>
#include <mutex>

struct Resource{
  Resource(const char*, const char*);
};

///unhide
class Widget
{
  mutable std::mutex m_;
  mutable std::optional<const Resource> resource_;

public:
  const Resource& getResource() const {
    std::lock_guard<std::mutex> lg{m_};
    if (resource_ == std::nullopt)
        resource_.emplace("resource", "arguments");

return *resource_;
  }
};
```

Note: `emplace` destructs any contained value and construct a new one by forwarding the arguments

---

## optional argument

```cpp
///options+=-std=c++17
///hide
#include <optional>

///unhide
template <typename T>
T getValue(std::optional<T> newVal = {})
{
  static T cached{};
  if (newVal) {
    cached = *newVal;
  }
  return cached;      
}
```

---

## in-place construction

```cpp
///options+=-std=c++17
///hide
#include <string>
#include <optional>
#include <cassert>

int main() {
///unhide
std::optional<std::string> o1{std::in_place, {'a', 'b', 'c'}};
assert(o1 == "abc");

std::optional<std::string> o2{std::in_place, 3, 'A'};
assert(o2 == "AAA");
///hide
}
```

Note: can construct non-movable types and saves constructing a temporary and moving it in for movable types

---

## alternatively

```cpp
///options+=-std=c++17
///hide
#include <string>
#include <optional>
#include <cassert>

int main() {
using namespace std::literals;
///unhide
auto o1 = std::make_optional<std::string>({'a', 'b', 'c'});
assert(o1 == "abc");

auto o2 = std::make_optional<std::string>(3, 'A');
assert(o2 == "AAA");

auto o3 = std::make_optional("123"s);
static_assert(std::is_same_v<decltype(o3), std::optional<std::string>>);
///hide
}
```

---

## no optional references

```cpp
///options+=-std=c++17
///fails=static_assert(!is_reference_v<_Tp>)
///hide
#include <optional>

int main() {
///unhide
int i = 1;
int j = 2;
std::optional<int&> ora = i;
ora = j; // assigns or rebinds
///hide
}
```

---

## use `std::reference_wrapper`

```cpp
///options+=-std=c++17
///hide
#include <optional>
#include <cassert>
#include <functional>

int main() {
///unhide
int i = 1;
int j = 2;
std::optional<std::reference_wrapper<int>> ora = i;
ora = j; // rebinds
assert(&ora->get() == &j);
///hide
}
```

Note: notice call to `operator->`

---

## Algebraic data types

Algebraically, a type is the number of values that inhabit it.

These types are equivalent:

```cpp
///options+=-fpermissive
bool;
enum class InatorButtons {
  ON_OFF,
  SELF_DESTRUCT
};
```

---

## LEVEL 2

How many values?

```cpp
///options+=-fpermissive
///hide
#include <utility>

///unhide
std::pair<char, bool>;
```

`$$ 256 \cdot 2 = 512 $$`

---

## LEVEL 2

How many values?

```cpp
struct Foo {
  char a;
  bool b;
};
```

`$$ 256 \cdot 2 = 512 $$`

---

## LEVEL 2

How many values?

```cpp
///options+=-fpermissive
///hide
#include <tuple>

///unhide
std::tuple<bool, bool, bool>;
```

`$$ 2 \cdot 2 \cdot 2 = 8 $$`

---

## LEVEL 2

How many values?

```cpp
template <typename T, typename U>
struct Foo {
  T m_t;
  U m_u;
};
```

`$$ |T| \cdot |U| $$`

---

## product types

- When two types are "concatenated" into one compound type, we multiply the # of inhabitants of the components.
- This kind of compounding gives us a product type

---

# END OF LEVEL 2

---

---

## variant

Source: [P0088R3](http://wg21.link/p0088r3), Axel Naumann

Note: we will take a look at some use cases for variant

---

## network connection

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<svg
   xmlns:osb="http://www.openswatchbook.org/uri/2009/osb"
   xmlns:dc="http://purl.org/dc/elements/1.1/"
   xmlns:cc="http://creativecommons.org/ns#"
   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
   xmlns:svg="http://www.w3.org/2000/svg"
   xmlns="http://www.w3.org/2000/svg"
   xmlns:sodipodi="http://sodipodi.sourceforge.net/DTD/sodipodi-0.dtd"
   xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
   width="168.91704mm"
   height="119.9695mm"
   viewBox="0 0 168.91704 119.9695"
   version="1.1"
   id="svg8"
   inkscape:version="1.0 (4035a4f, 2020-05-01)"
   sodipodi:docname="state_machine.svg">
  <defs
     id="defs2">
    <linearGradient
       id="linearGradient1257"
       osb:paint="solid">
      <stop
         style="stop-color:#000000;stop-opacity:1;"
         offset="0"
         id="stop1255" />
    </linearGradient>
    <marker
       inkscape:stockid="Arrow1Lend"
       orient="auto"
       refY="0"
       refX="0"
       id="Arrow1Lend"
       style="overflow:visible"
       inkscape:isstock="true">
      <path
         id="path922"
         d="M 0,0 5,-5 -12.5,0 5,5 Z"
         style="fill:none;fill-opacity:1;fill-rule:evenodd;stroke:#000000;stroke-width:1pt;stroke-opacity:1"
         transform="matrix(-0.8,0,0,-0.8,-10,0)" />
    </marker>
    <inkscape:path-effect
       effect="bspline"
       id="path-effect917"
       is_visible="true"
       lpeversion="1"
       weight="33.333333"
       steps="2"
       helper_size="0"
       apply_no_weight="true"
       apply_with_weight="true"
       only_selected="false" />
    <rect
       x="117.5701"
       y="134.36583"
       width="55.665844"
       height="17.275606"
       id="rect885" />
    <rect
       x="18.235363"
       y="134.8457"
       width="58.065235"
       height="17.755493"
       id="rect879" />
    <rect
       x="21.594509"
       y="47.028042"
       width="53.746334"
       height="14.396339"
       id="rect847" />
    <rect
       id="rect855"
       height="14.396339"
       width="53.746334"
       y="47.028042"
       x="21.594509" />
    <rect
       x="21.594509"
       y="47.028042"
       width="53.746334"
       height="14.396339"
       id="rect861" />
    <rect
       id="rect867"
       height="14.396339"
       width="53.746334"
       y="47.028042"
       x="21.594509" />
  </defs>
  <sodipodi:namedview
     id="base"
     pagecolor="#ffffff"
     bordercolor="#666666"
     borderopacity="1.0"
     inkscape:pageopacity="0.0"
     inkscape:pageshadow="2"
     inkscape:zoom="1.1027109"
     inkscape:cx="352.82162"
     inkscape:cy="266.48456"
     inkscape:document-units="mm"
     inkscape:current-layer="svg8"
     inkscape:document-rotation="0"
     showgrid="false"
     fit-margin-top="0"
     fit-margin-left="0"
     fit-margin-right="0"
     fit-margin-bottom="0"
     inkscape:window-width="1859"
     inkscape:window-height="1035"
     inkscape:window-x="61"
     inkscape:window-y="23"
     inkscape:window-maximized="1" />
  <metadata
     id="metadata5">
    <rdf:RDF>
      <cc:Work
         rdf:about="">
        <dc:format>image/svg+xml</dc:format>
        <dc:type
           rdf:resource="http://purl.org/dc/dcmitype/StillImage" />
        <dc:title />
      </cc:Work>
    </rdf:RDF>
  </metadata>
  <rect
     style="fill:#bee4fd;fill-opacity:1;stroke-width:0.11139;stroke-miterlimit:3.8;stroke-dasharray:none;stop-color:#000000"
     id="rect837"
     width="70.542061"
     height="45.108532"
     x="0"
     y="0.47987747"
     rx="11.0372"
     ry="11.0372" />
  <rect
     ry="11.0372"
     rx="11.0372"
     y="0"
     x="98.374977"
     height="45.108532"
     width="70.542061"
     id="rect839"
     style="fill:#bee4fd;fill-opacity:1;stroke-width:0.11139;stroke-miterlimit:3.8;stroke-dasharray:none;stop-color:#000000" />
  <rect
     style="fill:#bee4fd;fill-opacity:1;stroke-width:0.11139;stroke-miterlimit:3.8;stroke-dasharray:none;stop-color:#000000"
     id="rect841"
     width="70.542061"
     height="45.108532"
     x="0"
     y="74.860962"
     rx="11.0372"
     ry="11.0372" />
  <rect
     ry="11.0372"
     rx="11.0372"
     y="74.860962"
     x="98.374977"
     height="45.108532"
     width="70.542061"
     id="rect843"
     style="fill:#bee4fd;fill-opacity:1;stroke-width:0.11139;stroke-miterlimit:3.8;stroke-dasharray:none;stop-color:#000000" />
  <text
     xml:space="preserve"
     id="text845"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.05555999999999983px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect847);stroke-width:0.264583;stroke-miterlimit:3.8;stroke-dasharray:none;"
     transform="translate(-12.946434,-40.789627)"><tspan
       x="21.59375"
       y="53.464345"><tspan
         style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.05556px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583;stroke-miterlimit:3.8;stroke-dasharray:none">Disconnected</tspan></tspan></text>
  <text
     transform="translate(89.946792,-40.789627)"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.05555999999999983px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect855);stroke-width:0.264583;stroke-miterlimit:3.8;stroke-dasharray:none;"
     id="text853"
     xml:space="preserve"><tspan
       x="21.59375"
       y="53.464345"><tspan
         style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.05556px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583;stroke-miterlimit:3.8;stroke-dasharray:none">Connecting</tspan></tspan></text>
  <text
     xml:space="preserve"
     id="text859"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.05555999999999983px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect861);stroke-width:0.264583;stroke-miterlimit:3.8;stroke-dasharray:none;"
     transform="translate(91.324832,35.99443)"><tspan
       x="21.59375"
       y="53.464345"><tspan
         style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.05556px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583;stroke-miterlimit:3.8;stroke-dasharray:none">Connected</tspan></tspan></text>
  <text
     transform="translate(-9.5444006,35.99443)"
     style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.05555999999999983px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect867);stroke-width:0.264583;stroke-miterlimit:3.8;stroke-dasharray:none;"
     id="text865"
     xml:space="preserve"><tspan
       x="21.59375"
       y="53.464345"><tspan
         style="font-style:normal;font-variant:normal;font-weight:bold;font-stretch:normal;font-size:7.05556px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Bold';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583;stroke-miterlimit:3.8;stroke-dasharray:none">Interrupted</tspan></tspan></text>
  <rect
     style="fill:none;fill-opacity:1;stroke-width:0.11139;stroke-miterlimit:3.8;stroke-dasharray:none;stop-color:#000000"
     id="rect875"
     width="38.39024"
     height="11.037193"
     x="5.7585354"
     y="94.056076"
     rx="11.0372"
     ry="11.037193" />
  <text
     xml:space="preserve"
     id="text877"
     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.93888999999999978px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;white-space:pre;shape-inside:url(#rect879);stroke-width:0.264583;stroke-miterlimit:3.8;stroke-dasharray:none;"
     transform="translate(-12.476828,-41.936379)"><tspan
       x="18.236328"
       y="139.3516"><tspan
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.93889px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583;stroke-miterlimit:3.8;stroke-dasharray:none">- disconnected time
</tspan></tspan><tspan
       x="18.236328"
       y="145.52522"><tspan
         style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.93889px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583;stroke-miterlimit:3.8;stroke-dasharray:none">- reconnect timer</tspan></tspan></text>
  <g
     id="g1278"
     transform="matrix(0.39168222,0,0,0.554848,43.782054,12.88923)">
    <rect
       y="14.904021"
       x="69.929672"
       height="11.517071"
       width="47.880371"
       id="rect1271"
       style="fill:#cccccc;fill-opacity:1;stroke:none;stroke-width:1.71307;stroke-miterlimit:3.8;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000" />
    <path
       d="M 128.84724,17.995424 104.3953,13.877392 120.18759,-5.2395881 Z"
       transform="rotate(81.179365,113.70222,18.111573)"
       inkscape:transform-center-y="0.33344369"
       inkscape:transform-center-x="-1.3130624"
       inkscape:randomized="0"
       inkscape:rounded="0"
       inkscape:flatsided="true"
       sodipodi:arg2="1.737644"
       sodipodi:arg1="0.69044646"
       sodipodi:r2="7.1580677"
       sodipodi:r1="14.316136"
       sodipodi:cy="8.8777428"
       sodipodi:cx="117.81004"
       sodipodi:sides="3"
       id="path1274"
       style="fill:#cccccc;fill-opacity:1;stroke:none;stroke-width:2;stroke-miterlimit:3.8;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       sodipodi:type="star" />
  </g>
  <text
     xml:space="preserve"
     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.88056px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583"
     x="73.8181"
     y="25.437637"
     id="text1282"><tspan
       sodipodi:role="line"
       id="tspan1280"
       x="73.8181"
       y="25.437637"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.88056px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583">connect()</tspan></text>
  <g
     transform="matrix(-0.39168222,0,0,-0.554848,125.13499,108.87981)"
     id="g1295">
    <rect
       style="fill:#cccccc;fill-opacity:1;stroke:none;stroke-width:1.71307;stroke-miterlimit:3.8;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="rect1291"
       width="47.880371"
       height="11.517071"
       x="69.929672"
       y="14.904021" />
    <path
       d="M 128.84724,17.995424 104.3953,13.877392 120.18759,-5.2395881 Z"
       sodipodi:type="star"
       style="fill:#cccccc;fill-opacity:1;stroke:none;stroke-width:2;stroke-miterlimit:3.8;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="path1293"
       sodipodi:sides="3"
       sodipodi:cx="117.81004"
       sodipodi:cy="8.8777428"
       sodipodi:r1="14.316136"
       sodipodi:r2="7.1580677"
       sodipodi:arg1="0.69044646"
       sodipodi:arg2="1.737644"
       inkscape:flatsided="true"
       inkscape:rounded="0"
       inkscape:randomized="0"
       inkscape:transform-center-x="-1.3130624"
       inkscape:transform-center-y="0.33344369"
       transform="rotate(81.179365,113.70222,18.111573)" />
  </g>
  <text
     id="text1299"
     y="98.499054"
     x="77.52227"
     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.88056px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583"
     xml:space="preserve"><tspan
       sodipodi:role="line"
       id="tspan1308"
       x="77.52227"
       y="98.499054">interrupt()</tspan></text>
  <g
     transform="matrix(-0.34599984,-0.32538184,0.46092841,-0.4901354,110.08845,104.06032)"
     id="g1314">
    <rect
       style="fill:#cccccc;fill-opacity:1;stroke:none;stroke-width:1.71307;stroke-miterlimit:3.8;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="rect1310"
       width="47.880371"
       height="11.517071"
       x="69.929672"
       y="14.904021" />
    <path
       sodipodi:type="star"
       style="fill:#cccccc;fill-opacity:1;stroke:none;stroke-width:2;stroke-miterlimit:3.8;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="path1312"
       sodipodi:sides="3"
       sodipodi:cx="117.81004"
       sodipodi:cy="8.8777428"
       sodipodi:r1="14.316136"
       sodipodi:r2="7.1580677"
       sodipodi:arg1="0.69044646"
       sodipodi:arg2="1.737644"
       inkscape:flatsided="true"
       inkscape:rounded="0"
       inkscape:randomized="0"
       inkscape:transform-center-x="-1.3130624"
       inkscape:transform-center-y="0.33344369"
       transform="rotate(81.179365,113.70222,18.111573)"
       d="M 128.84724,17.995424 104.3953,13.877392 120.18759,-5.2395881 Z" />
  </g>
  <text
     id="text1318"
     y="-12.534634"
     x="93.322624"
     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.88056px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583"
     xml:space="preserve"
     transform="rotate(43.24101)"><tspan
       sodipodi:role="line"
       id="tspan1327"
       x="93.322624"
       y="-12.534634">disconnect()</tspan></text>
  <g
     transform="matrix(0,0.39168222,-0.554848,0,145.11059,19.308275)"
     id="g1335">
    <rect
       style="fill:#cccccc;fill-opacity:1;stroke:none;stroke-width:1.71307;stroke-miterlimit:3.8;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="rect1331"
       width="47.880371"
       height="11.517071"
       x="69.929672"
       y="14.904021" />
    <path
       d="M 128.84724,17.995424 104.3953,13.877392 120.18759,-5.2395881 Z"
       sodipodi:type="star"
       style="fill:#cccccc;fill-opacity:1;stroke:none;stroke-width:2;stroke-miterlimit:3.8;stroke-dasharray:none;stroke-opacity:1;stop-color:#000000"
       id="path1333"
       sodipodi:sides="3"
       sodipodi:cx="117.81004"
       sodipodi:cy="8.8777428"
       sodipodi:r1="14.316136"
       sodipodi:r2="7.1580677"
       sodipodi:arg1="0.69044646"
       sodipodi:arg2="1.737644"
       inkscape:flatsided="true"
       inkscape:rounded="0"
       inkscape:randomized="0"
       inkscape:transform-center-x="-1.3130624"
       inkscape:transform-center-y="0.33344369"
       transform="rotate(81.179365,113.70222,18.111573)" />
  </g>
  <text
     id="text1339"
     y="-132.56219"
     x="47.756821"
     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:3.175px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583"
     xml:space="preserve"
     transform="rotate(90)"><tspan
       sodipodi:role="line"
       id="tspan1348"
       x="47.756821"
       y="-132.56219">acknowledge()</tspan></text>
  <text
     xml:space="preserve"
     style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.93889px;line-height:1.25;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583"
     x="105.57316"
     y="97.415222"
     id="text1385"><tspan
       sodipodi:role="line"
       id="tspan1383"
       x="105.57316"
       y="97.415222"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.93889px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583">- last ping time</tspan><tspan
       sodipodi:role="line"
       x="105.57316"
       y="103.58884"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.93889px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583"
       id="tspan1387">- connected time</tspan><tspan
       sodipodi:role="line"
       x="105.57316"
       y="109.76244"
       style="font-style:normal;font-variant:normal;font-weight:normal;font-stretch:normal;font-size:4.93889px;font-family:sans-serif;-inkscape-font-specification:'sans-serif, Normal';font-variant-ligatures:normal;font-variant-caps:normal;font-variant-numeric:normal;font-variant-east-asian:normal;stroke-width:0.264583"
       id="tspan1389">- connection ID</tspan></text>
</svg>

Source: [Using Types Effectively](https://www.youtube.com/watch?v=ojZbFIQSdl8), Ben Deane, CppCon 2016

Note: network connections are implemented many times using a state machine similar to the one presented here. some of the states have data fields relevant to those states.

---

## a connection

```cpp [1-8,15|9|10-14]
///options+=-std=c++17
///hide
#include <chrono>
#include <string>
#include <optional>

struct ConnectionId {};
struct Timer {};

///unhide
struct Connection {
  enum class State {
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    CONNECTION_INTERRUPTED
  };
  State m_state = State::DISCONNECTED;
  std::string m_serverAddress;
  ConnectionId m_id;
  std::chrono::system_clock::time_point m_connectedTime;
  std::optional<std::chrono::milliseconds> m_lastPingTime;
  std::chrono::system_clock::time_point m_disconnectedTime;
  Timer m_reconnectTimer;
};
```

Note: here is a naive implementation of such a connection holding a current state field, server address, which, for the sake of discussion, is relevant to all states and state specific data fields.

---

## state transitions

```cpp [1-16|18-21]
///options+=-std=c++17
///hide
#include <chrono>
#include <string>
#include <optional>

struct ConnectionId {};
struct Timer {
    Timer(size_t);
};

struct Connection {
  enum class State {
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    CONNECTION_INTERRUPTED
  };
  std::string m_serverAddress;
  ConnectionId m_id;
  std::chrono::system_clock::time_point m_connectedTime;
  std::optional<std::chrono::milliseconds> m_lastPingTime;
  std::chrono::system_clock::time_point m_disconnectedTime;
  Timer m_reconnectTimer;
  State m_state = State::DISCONNECTED;

void notifyInterrupted(std::chrono::system_clock::time_point);

///unhide
void interrupt() {
  switch (m_state) {
    case State::DISCONNECTED:
    case State::CONNECTING:
      m_state = State::DISCONNECTED;
      break;
    case State::CONNECTED:
      m_disconnectedTime = std::chrono::system_clock::now();
      notifyInterrupted(m_disconnectedTime);
      m_reconnectTimer = Timer{5000};
      m_state = State::CONNECTION_INTERRUPTED;
      break;
    case State::CONNECTION_INTERRUPTED:
      break;
  }
}

void disconnect() {
  // maybe need to kill timer?
  m_state = State::DISCONNECTED;
}
///hide
};
```

Note:

- Data is accessible where it shouldn’t be
- not RAII as state stays alive when not needed
- We want to make illegal states unrepresentable

---

## `std::variant`

```cpp [1-3|5-6|8-13|15-19|21|23-24]
///options+=-std=c++17
///output=42\nstd::get: wrong index for variant\nwe don't have a string\nforty two
///hide
#include <iostream>
///unhide
#include <variant>

///hide
int main() {
///unhide
std::variant<int, std::string> v;

v = 42;
std::cout << std::get<int>(v) << '\n';

try {
  std::cout << std::get<std::string>(v) << '\n';
}
catch (const std::bad_variant_access &e) {
  std::cout << e.what() << '\n';
}

if (auto p = std::get_if<std::string>(&v)) {
  std::cout << "we have a string: " << *p << '\n';}
else {
  std::cout << "we don't have a string\n";
}

// std::cout << std::get<long>(v) << '\n';

v = "forty two";
std::cout << std::get<std::string>(v) << '\n';
///hide
}
```

Note:

- a variant can hold one of a predefined list of types, `int` and `string` in this example.
- you can think of it as a type-safe union.
- can't get `long` even though `int` implicitly converts to it.

---

## in-place construction

```cpp [1-5|1,7-9|1,11]
///options+=-std=c++17
///hide
#include <string>
#include <variant>
#include <cassert>
#include <vector>

int main() {
///unhide
using Var = std::variant<std::string, std::vector<int>, float>;

Var var{std::in_place_type<std::string>, 4, 'A'};
assert(var.index() == 0);
assert(std::get<0>(var) == "AAAA");

var = Var{std::in_place_index<1>, {1, 2, 3}};
assert(std::holds_alternative<std::vector<int>>(var));
assert(std::get<std::vector<int>>(var).size() == 3);

var.emplace<float>(4.2);
///hide
}
```

Note: can construct non-movable types and saves constructing a temporary and moving it in for movable types

---

## visiting

```cpp
///options+=-std=c++17
///hide
#include <variant>
#include <string>

///unhide
using Var = std::variant<int, std::string>;

Var duplicate(const Var& v) {
  struct Duplicater {
    Var operator()(int i) { return i * 2; }
    Var operator()(const std::string &s) {
    return s + s;
    }
  };
  return std::visit(Duplicater{}, v);
}
```

Note: the main way to interact with variants is std::visit. it accepts a callable with multiple call operators and call one of them based on the current value of the variant. all visitors should have the same return type and there should be a single visitor matching each variant type.

---

## overload set - C++14

```cpp [1-3,21|5-10|12-20|23-26]
///hide
#include <utility>

///unhide
namespace impl {
template <typename...>
struct overload_set;

template <typename F>
struct overload_set<F> : F {
  using F::operator();

overload_set(F &&f) noexcept : F(std::forward<F>(f)) {}
};

template <typename F, typename... Fs>
struct overload_set<F, Fs...> : F, overload_set<Fs...> {
  overload_set(F&& f, Fs&&... fs) noexcept
      : F(std::forward<F>(f)),
        overload_set<Fs...>(std::forward<Fs>(fs)...) {}

using F::operator();
  using overload_set<Fs...>::operator();
};
}  // namespace impl

template <typename... Fs>
auto overload(Fs&&... fs) noexcept {
  return impl::overload_set<Fs...>{std::forward<Fs>(fs)...};
}
///hide

auto x = overload([]{ return 42; })();
```

Note: we would like to use lambdas for visiting variants instead of ad-hoc function objects.

---

## overload set - C++17

```cpp []
///options+=-std=c++17
///hide
#include <utility>

///unhide
namespace impl {
template <typename... Fs>
struct overload_set : Fs... {
  constexpr overload_set(Fs&&... fs) noexcept
      : Fs(std::forward<Fs>(fs))... {}

using Fs::operator()...;
};
}  // namespace impl

template <typename... Fs>
constexpr auto overload(Fs&&... fs) noexcept {
  return impl::overload_set<Fs...>{std::forward<Fs>(fs)...};
}
///hide

static_assert(overload([]{ return 42; })() == 42);
```

Note: `constexpr` lambda + variadic using

---

## lambda visitation

```cpp
///options+=-std=c++17
///hide
#include <variant>
#include <utility>
#include <string>

namespace impl {
template <typename... Fs>
struct overload_set : Fs... {
  constexpr overload_set(Fs &&...fs) noexcept
      : Fs(std::forward<Fs>(fs))... {}

using Fs::operator()...;
};
}  // namespace impl

template <typename... Fs>
constexpr auto overload(Fs &&...fs) noexcept {
  return impl::overload_set<Fs...>{std::forward<Fs>(fs)...};
}
///unhide
using Var = std::variant<int, std::string>;

Var duplicate(const Var& v) {
  return std::visit(overload(
    [](int i) -> Var { return i * 2; },
    [](const std::string &s) -> Var { return s + s; }
  ), v);
}
```

---

## explicit return type (C++20)

```cpp
///options+=-std=c++2a
///hide
#include <variant>
#include <utility>
#include <string>

namespace impl {
template <typename... Fs>
struct overload_set : Fs... {
  constexpr overload_set(Fs &&...fs) noexcept
      : Fs(std::forward<Fs>(fs))... {}

using Fs::operator()...;
};
}  // namespace impl

template <typename... Fs>
constexpr auto overload(Fs &&...fs) noexcept {
  return impl::overload_set<Fs...>{std::forward<Fs>(fs)...};
}
///unhide
using Var = std::variant<int, std::string>;

Var duplicate(const Var& v) {
  return std::visit<Var>(overload(
    [](int i) { return i * 2; },
    [](const std::string &s) { return s + s; }
  ), v);
}
```

Note: we define the return type once on `std::visit`

---

## `constexpr if`   visitation

```cpp
///options+=-std=c++17
///hide
#include <variant>
#include <string>
#include <type_traits>

///unhide
using Var = std::variant<int, std::string>;

Var duplicate(const Var& v) {
  return std::visit([](const auto& value)->Var {
    if constexpr (std::is_same_v<decltype(value), int>) {
      return value * 2; 
    } else {
      return value + value;
    }
  }, v);
}
```

---

## back to connection

```cpp [13-15|2-12|16]
///options+=-std=c++17
///hide
#include <chrono>
#include <string>
#include <optional>
#include <variant>

struct ConnectionId {};
struct Timer {};

///unhide
struct Connection {
  struct Disconnected {};
  struct Connecting {};
  struct Connected {
    ConnectionId m_id;
    std::chrono::system_clock::time_point m_connectedTime;
    std::optional<std::chrono::milliseconds> m_lastPingTime;
  };
  struct ConnectionInterrupted {
    std::chrono::system_clock::time_point m_disconnectedTime;
    Timer m_reconnectTimer;
  };
  using State =
  std::variant<Disconnected, Connecting, Connected, ConnectionInterrupted>;
  State m_state;
  std::string m_serverAddress;
};
```

---

## state transition

```cpp [1-2,10-11|3-7|8|9]
///options+=-std=c++17
///hide
#include <chrono>
#include <string>
#include <optional>
#include <variant>

namespace impl {
template <typename... Fs>
struct overload_set : Fs... {
  constexpr overload_set(Fs &&...fs) noexcept
      : Fs(std::forward<Fs>(fs))... {}

using Fs::operator()...;
};
}  // namespace impl

template <typename... Fs>
constexpr auto overload(Fs &&...fs) noexcept {
  return impl::overload_set<Fs...>{std::forward<Fs>(fs)...};
}

struct ConnectionId {};
struct Timer {
  Timer(size_t);
};

struct Connection {
  struct Disconnected {};
  struct Connecting {};
  struct Connected {
    ConnectionId m_id;
    std::chrono::system_clock::time_point m_connectedTime;
    std::optional<std::chrono::milliseconds> m_lastPingTime;
  };
  struct ConnectionInterrupted {
    std::chrono::system_clock::time_point m_disconnectedTime;
    Timer m_reconnectTimer;
  };
  using State =
  std::variant<Disconnected, Connecting, Connected, ConnectionInterrupted>;
  State m_state;
  std::string m_serverAddress;

void notifyInterrupted(std::chrono::system_clock::time_point);

///unhide
void interrupt() {
  m_state = std::visit(overload(
    [this](const Connected &) -> State {
      const auto now = std::chrono::system_clock::now();
      notifyInterrupted(now);
      return ConnectionInterrupted{now, 5000};
    },
    [](const ConnectionInterrupted &s) -> State { return s; },
    [](const auto & /*default*/) -> State { return Disconnected(); }
  ), m_state);
}
///hide
};
```

Note: each state can only access its own fields, and those fields are destroyed when state is transitioned.

---

## json

<div>

- Null
- Number
- String
- Boolean
- Array of JSON
- Map of string -> JSON

</div>

```json
///fails=expected unqualified-id before '{' token
{
  "firstName": "John",
  "lastName": "Smith",
  "isAlive": true,
  "age": 27,
  "address": {
    "streetAddress": "21 2nd Street",
    "city": "New York"
  },
  "phoneNumbers": [
    {
      "type": "home",
      "number": "212 555-1234"
    },
    {
      "type": "office",
      "number": "646 555-4567"
    }
  ],
  "spouse": null
}
```

<div>

Note: you are all familiar with the JSON format in which every value can be one of this list of types. you can see an example of a JSON object describing some person. It is very natural to represent such types with a variant.

---

## recursive variant

```cpp
///options+=-std=c++17
///fails='JsonValue' was not declared in this scope
///hide
#include <map>
#include <string>
#include <variant>
#include <vector>

///unhide
using JsonValue = std::variant<
  nullptr_t,                        // null
  int,                              // number
  std::string,                      // string
  bool,                             // boolean
  std::vector<JsonValue>,           // array
  std::map<std::string, JsonValue>  // object
>;
```

Note: does not compile

---

## Fundamental theorem of software engineering

> We can solve any problem by introducing an extra level of indirection.
>
> <cite>Andrew Koenig</cite>

---

#### containers of incomplete types (C++17)

```cpp [1-3|4-10|11-14]
///options+=-std=c++17
///hide
#include <map>
#include <string>
#include <variant>
#include <vector>

///unhide
struct JsonValue;
using JsonArray = std::vector<JsonValue>;
using JsonObject = std::map<std::string, JsonValue>;
using Base = std::variant<std::nullptr_t, // null
                          int,            // number
                          std::string,    // string
                          bool,           // boolean
                          JsonArray,      // array
                          JsonObject      // object
                          >;
struct JsonValue : Base
{
  using Base::Base;
};
```

Note: luckily, C++17 also enables having containers of incomplete types.

---

## tests

```cpp []
///options+=-std=c++17
///hide
#include <map>
#include <string>
#include <variant>
#include <vector>
#include <cassert>

struct JsonValue;
using JsonArray = std::vector<JsonValue>;
using JsonObject = std::map<std::string, JsonValue>;
using Base = std::variant<std::nullptr_t, // null
                          int,            // number
                          std::string,    // string
                          bool,           // boolean
                          JsonArray,      // array
                          JsonObject      // object
                          >;
struct JsonValue : Base
{
  using Base::Base;
};
int main() {
///unhide
assert(std::holds_alternative<std::nullptr_t>(JsonValue{nullptr}));
assert(std::holds_alternative<int>(JsonValue{42}));
assert(std::holds_alternative<std::string>(JsonValue{"hello"}));
assert(std::holds_alternative<bool>(JsonValue{true}));
///hide
}
```

Note: constructing a JsonValue with each of the simple types correctly sets the variant type

---

## more tests

```cpp []
///options+=-std=c++17
///fails=no matching function for call to 'JsonValue::JsonValue(<brace-enclosed initializer list>)'
///hide
#include <map>
#include <string>
#include <variant>
#include <vector>
#include <cassert>

struct JsonValue;
using JsonArray = std::vector<JsonValue>;
using JsonObject = std::map<std::string, JsonValue>;
using Base = std::variant<std::nullptr_t, // null
                          int,            // number
                          std::string,    // string
                          bool,           // boolean
                          JsonArray,      // array
                          JsonObject      // object
                          >;
struct JsonValue : Base
{
  using Base::Base;
};
int main() {
///unhide
assert(std::holds_alternative<JsonArray>(JsonValue{1, "goodbye"}));
assert(std::holds_alternative<JsonObject>(JsonValue{{"1", "goodbye"}}));
///hide
}
```

Note: trying to construct the compound types fails to compile because the compiler can't deduce the requested type

---

## add a constructor

```cpp [5-6|9-10,32|11-17|19-29|31|35-36]
///options+=-std=c++17
///hide
#include <map>
#include <string>
#include <variant>
#include <vector>
#include <algorithm>
#include <cassert>

JsonValue(std::initializer_list<JsonValue> init) 
  : Base{fromInitList(init)} {}

private:
  static Base fromInitList(std::initializer_list<JsonValue> init)
  {
    auto isObject = std::all_of(init.begin(), init.end(), 
                                [](const JsonValue &v) {
      auto asArray = std::get_if<JsonArray>(&v);
      return asArray 
        && asArray->size() == 2 
        && std::holds_alternative<std::string>(asArray->at(0));
    });

if (isObject)
    {
      JsonObject obj;
      std::transform(init.begin(), init.end(), std::inserter(obj, obj.end()), 
                     [](const JsonValue &v) {
        auto asArray = std::get<JsonArray>(v);
        return std::make_pair(std::get<std::string>(asArray[0]), 
                              asArray[1]);
      });
      return obj;
    }

return JsonArray{init.begin(), init.end()};
  }
};

///hide
int main() {
///unhide
assert(std::holds_alternative<JsonArray>(JsonValue{1, "goodbye"}));
assert(std::holds_alternative<JsonObject>(JsonValue{{"1", "goodbye"}}));
///hide
}
```

---

## JSON readability

```cpp
///options+=-std=c++17
///hide
#include <map>
#include <string>
#include <variant>
#include <vector>

JsonValue(std::initializer_list<JsonValue> init);
};

///unhide
JsonValue person{
      {"firstName", "John"},
      {"lastName", "Smith"},
      {"isAlive", true},
      {"age", 27},
      {"address", {
          {"streetAddress", "21 2nd Street"}, 
          {"city", "New York"}
        }
      },
      {"phoneNumbers", {
        {
          {"type", "home"}, 
          {"number", "212 555-1234"}
        },
        {
          {"type", "office"}, 
          {"number", "646 555-4567"}}
        },
      },
      {"spouse", nullptr}
    };
```

</div>

---

> Inheritance is the base class of evil
>
> <cite>Sean Parent</cite>

---

## inheritance - base class

```cpp
struct Shape {
  virtual double area() const = 0;
  virtual ~Shape() = default;
};
```

---

## inheritance - derived classes

```cpp
///hide
#include <cmath>
    
static const auto PI = acos(-1);

struct Shape {
  virtual double area() const = 0;
  virtual ~Shape() = default;
};

///unhide
struct Square final : Shape {
  explicit Square(double length) : length{ length } {}
  double area() const override { return length * length; }
  double length;
};

struct Circle final : Shape {
  explicit Circle(double radius) : radius{ radius } {}
  double area() const override {
    return PI * radius * radius;
  }
  double radius;
};
```

Note: forces all participant types to inherit from base type

---

## inheritance - usage

```cpp
///hide
#include <cmath>
#include <cassert>
#include <numeric>
#include <memory>
    
static const auto PI = acos(-1);

struct Shape {
  virtual double area() const = 0;
  virtual ~Shape() = default;
};

struct Square final : Shape {
  explicit Square(double length) : length{ length } {}
  double area() const override { return length * length; }
  double length;
};

struct Circle final : Shape {
  explicit Circle(double radius) : radius{ radius } {}
  double area() const override {
    return PI * radius * radius;
  }
  double radius;
};

int main() {
///unhide
const std::unique_ptr<Shape> shapes[] = {
  std::make_unique<Square>(4),
  std::make_unique<Circle>(2)
};

const auto areaSum = 
  std::accumulate(std::begin(shapes), std::end(shapes), 0.0,
                  [](double current, const auto& shape) {
                    return current + shape->area();
                  });
assert(areaSum == 16 + 4 * PI);
///hide
}
```

Note: forces heap allocation and pointer semantics

---

## variant - classes

```cpp
///options+=-std=c++17
///hide
#include <variant>

///unhide
struct Square {
  explicit Square(double length) : length{length} {}
  double length;
};

struct Circle {
  explicit Circle(double radius) : radius{radius} {}
  double radius;
};

using Shape = std::variant<Square, Circle>;
```

Note: types are less coupled

---

## variant - behavior

```cpp
///options+=-std=c++17
///hide
#include <variant>
#include <cmath>
    
static const auto PI = acos(-1);

struct Square {
  explicit Square(double length) : length{length} {}
  double length;
};

struct Circle {
  explicit Circle(double radius) : radius{radius} {}
  double radius;
};

using Shape = std::variant<Square, Circle>;

namespace impl {
template <typename... Fs>
struct overload_set : Fs... {
  constexpr overload_set(Fs &&...fs) noexcept
      : Fs(std::forward<Fs>(fs))... {}

using Fs::operator()...;
};
}  // namespace impl

template <typename... Fs>
constexpr auto overload(Fs &&...fs) noexcept {
  return impl::overload_set<Fs...>{std::forward<Fs>(fs)...};
}

///unhide
double area(const Shape &shape) {
  return std::visit(overload(
      [](const Square &square) { return square.length * square.length; },
      [](const Circle &circle) { return PI * circle.radius * circle.radius; }
    ), shape);
}
```

Note: we could have here even have some library types which we don't control or even primitive types

---

## variant - usage

```cpp
///options+=-std=c++17
///hide
#include <variant>
#include <cmath>
#include <numeric>
#include <cassert>
#include <iterator>
    
static const auto PI = acos(-1);

struct Square {
  explicit Square(double length) : length{length} {}
  double length;
};

struct Circle {
  explicit Circle(double radius) : radius{radius} {}
  double radius;
};

using Shape = std::variant<Square, Circle>;

namespace impl {
template <typename... Fs>
struct overload_set : Fs... {
  constexpr overload_set(Fs &&...fs) noexcept
      : Fs(std::forward<Fs>(fs))... {}

using Fs::operator()...;
};
}  // namespace impl

template <typename... Fs>
constexpr auto overload(Fs &&...fs) noexcept {
  return impl::overload_set<Fs...>{std::forward<Fs>(fs)...};
}

double area(const Shape &shape) {
  return std::visit(overload(
    [](const Square &square) { 
      return square.length * square.length; 
    },
    [](const Circle &circle) {
      return PI * circle.radius * circle.radius;
    }),
  shape);
}

int main() {
///unhide
const Shape shapes[] = {Square{4}, Circle{2}};

const auto areaSum = 
  std::accumulate(std::begin(shapes), std::end(shapes), 0.0,
                  [](double current, const auto& shape) {
                    return current + area(shape);
                  });
assert(areaSum == 16 + 4 * PI);
///hide
}
```

Note: no heap allocation, value semantics

---

## inheritance – adding functionality

```cpp [3,10,17]
///hide
#include <cmath>
    
static const auto PI = acos(-1);

///unhide
struct Shape {
  virtual double area() const = 0;
  virtual double perimeter() const = 0;
  virtual ~Shape() = default;
};

struct Square final : Shape {
  explicit Square(double length) : length{ length } {}
  double area() const override { return length * length; }
  double perimeter() const override { return 4 * length; }
  double length;
};

struct Circle final : Shape {
  explicit Circle(double radius) : radius{ radius } {}
  double area() const override { return PI * radius * radius; }
  double perimeter() const override { return 2 * PI * radius; }
  double radius;
};
```

---

## variant – adding functionality

```cpp
///options+=-std=c++17
///hide
#include <variant>
#include <cmath>
    
static const auto PI = acos(-1);

struct Square {
  explicit Square(double length) : length{length} {}
  double length;
};

struct Circle {
  explicit Circle(double radius) : radius{radius} {}
  double radius;
};

using Shape = std::variant<Square, Circle>;

namespace impl {
template <typename... Fs>
struct overload_set : Fs... {
  constexpr overload_set(Fs &&...fs) noexcept
      : Fs(std::forward<Fs>(fs))... {}

using Fs::operator()...;
};
}  // namespace impl

template <typename... Fs>
constexpr auto overload(Fs &&...fs) noexcept {
  return impl::overload_set<Fs...>{std::forward<Fs>(fs)...};
}

///unhide
double perimeter(const Shape &shape) {
  return std::visit(overload(
    [](const Square &square) { return 4 * square.length; },
    [](const Circle &circle) { return 2 * PI * circle.radius; }
    ), shape);
}
```

Note: no need to change the types

---

## inheritance – adding type

```cpp
///hide
struct Shape {
  virtual double area() const = 0;
  virtual ~Shape() = default;
};

///unhide
struct Triangle : Shape {
  Triangle(double base, double height) : base{base}, height{height} {}
  double area() const override { return base * height / 2; }
  double base, height;
};
```

---

## variant - adding type

```cpp
///options+=-std=c++17
///hide
#include <variant>

struct Square {
  explicit Square(double length) : length{length} {}
  double length;
};

struct Circle {
  explicit Circle(double radius) : radius{radius} {}
  double radius;
};

///unhide
struct Triangle {
  Triangle(double base, double height) : base{base}, height{height} {}
  double base, height;
};

using Shape = std::variant<Square, Circle, Triangle>;
```

---

## compiler to the rescue

```cpp
///options+=-std=c++17
///fails=no matching function for call to '__invoke(impl::overload_set<area(const Shape&)::<lambda(const Square&)>, area(const Shape&)::<lambda(const Circle&)> >, const Triangle&)'
///hide
#include <variant>
#include <cmath>
    
static const auto PI = acos(-1);

struct Square {
  explicit Square(double length) : length{length} {}
  double length;
};

struct Circle {
  explicit Circle(double radius) : radius{radius} {}
  double radius;
};

struct Triangle {
  Triangle(double base, double height) : base{base}, height{height} {}
  double base, height;
};

using Shape = std::variant<Square, Circle, Triangle>;

namespace impl {
template <typename... Fs>
struct overload_set : Fs... {
  constexpr overload_set(Fs &&...fs) noexcept
      : Fs(std::forward<Fs>(fs))... {}

using Fs::operator()...;
};
}  // namespace impl

template <typename... Fs>
constexpr auto overload(Fs &&...fs) noexcept {
  return impl::overload_set<Fs...>{std::forward<Fs>(fs)...};
}

---

## compiler to the rescue

```cpp
///options+=-std=c++17
///hide
#include <variant>
#include <cmath>
    
static const auto PI = acos(-1);

struct Square {
  explicit Square(double length) : length{length} {}
  double length;
};

struct Circle {
  explicit Circle(double radius) : radius{radius} {}
  double radius;
};

struct Triangle {
  Triangle(double base, double height) : base{base}, height{height} {}
  double base, height;
};

using Shape = std::variant<Square, Circle, Triangle>;

namespace impl {
template <typename... Fs>
struct overload_set : Fs... {
  constexpr overload_set(Fs &&...fs) noexcept
      : Fs(std::forward<Fs>(fs))... {}

using Fs::operator()...;
};
}  // namespace impl

template <typename... Fs>
constexpr auto overload(Fs &&...fs) noexcept {
  return impl::overload_set<Fs...>{std::forward<Fs>(fs)...};
}

---

| Inheritance | std::variant |
|-------------|--------------|
| Need not know all the derived types upfront (open-world assumption) | Must know all the cases upfront (closed-world assumption) |
| Dynamic Allocation (usually) | No dynamic allocation |
| Intrusive (must inherit from the base class) | Non-intrusive (third-party classes can participate) |
| Reference semantics | Value semantics |
| Algorithm scattered into classes | Algorithm in one place |
| Language supported | Library supported |
| Creates a first-class abstraction | It’s just a container |
| Keeps fluent interfaces | Disables fluent interfaces |
| Adding a new operation (generally) boils down to implementing a polymorphic method in all the classes | Adding a new operation simply requires writing a new free function |

Source: [Inheritance vs std::variant](http://cpptruths.blogspot.com/2018/02/inheritance-vs-stdvariant-based.html), C++ TRUTHS

---

## LEVEL 3

How many values?

```cpp
///options+=-std=c++17 -fpermissive
///hide
#include <optional>

///unhide
std::optional<char>;
```

`$$ 256 + 1 = 257 $$`

---

## LEVEL 3

How many values?

```cpp
///options+=-std=c++17 -fpermissive
///hide
#include <variant>

///unhide
std::variant<char, bool>;
```

`$$ 256 + 2 = 258 $$`

---

## LEVEL 3

How many values?

```cpp
///options+=-std=c++17 -fpermissive
///hide
#include <variant>

///unhide
template <typename T, typename U>
struct Foo {
  std::variant<T, U> m_v;
};
```

`$$ |T| + |U| $$`

---

## sum types

- When two types are "alternated" into one compound type, we add the # of inhabitants of the components.
- This kind of compounding gives us a sum type.

---

## any

---

> design a generic event queue which supports enqueuing arbitrary events and holds a thread which dispatches enqueued events to subscribed handlers.

---

## generic event queue

```cpp [1-9|11-22]
///hide
#include <chrono>
#include <iostream>

///unhide
class EventQueue
{
public:
  template<typename Data>
  void enqueue(Data data);

template<typename Data, typename Handler>
  void subscribe(Handler&& handler);
};

///hide
template<typename Data>
void EventQueue::enqueue(Data data) {}

template<typename Data, typename Handler>
void EventQueue::subscribe(Handler&& handler) {}

void use() {
using namespace std::literals;
///unhide
EventQueue eq;

eq.subscribe<int>([](int i){
  std::cout << "got int " << i << '\n';
});

eq.subscribe<std::string>([](const std::string& s){
  std::cout << "got string " << s << '\n';
});

eq.enqueue(42);
eq.enqueue("hi"s);
///hide
}
```

---

## `std::any`

```cpp [1|4-6|8-14]
///options+=-std=c++17
///hide
#include <cassert>
#include <string>
///unhide
#include <any>

int main() {
  std::any a;

assert(!a.has_value());

a = std::string("hello");
  assert(a.has_value());
  assert(a.type() == typeid(std::string));

a = 42;
  assert(a.has_value());
  assert(a.type() == typeid(int));
}
```

---

## `std::any_cast`

```cpp [1-3|5-10|12-18|20-31]
///options+=-std=c++17
///hide
#include <string>
#include <iostream>
#include <any>
#include <utility>
 
int main()
{
///unhide
auto a = std::any{12};

std::cout << std::any_cast<int>(a) << '\n';

try {
  std::cout << std::any_cast<std::string>(a) << '\n';
}
catch(const std::bad_any_cast& e) {
  std::cout << e.what() << '\n';
}

if (int* i = std::any_cast<int>(&a)) {
  std::cout << "a is int: " << *i << '\n';
} else if (std::string* s = std::any_cast<std::string>(&a)) {
  std::cout << "a is std::string: " << *s << '\n';
} else {
  std::cout << "a is another type or unset\n";
}

a = std::string{"hello"};

auto& ra = std::any_cast<std::string&>(a);
ra[1] = 'o';

std::cout << "a: "
  << std::any_cast<const std::string&>(a) << '\n';

auto b = std::any_cast<std::string&&>(std::move(a));

std::cout << "a: " << *std::any_cast<std::string>(&a)
    << "b: " << b << '\n';
///hide
}
```

Note: `b` is a move-constructed std::string, `a` is left in valid but unspecified state

---

## in-place construction

```cpp
///options+=-std=c++17
///hide
#include <string>
#include <any>
#include <cassert>
#include <vector>
#include <complex>

int main() {
///unhide
std::any a{std::in_place_type<std::string>, 4, 'A'};
assert(std::any_cast<std::string>(a) == "AAAA");

a.emplace<std::vector<int>>({1, 2, 3, 4, 5});
assert(std::any_cast<std::vector<int>>(a).size() == 5);

a = std::make_any<std::complex<double>>(3, 4);
assert(std::abs(std::any_cast<std::complex<double>>(a)) == 5);
///hide
}
```

Note: can construct non-movable types and saves constructing a temporary and moving it in for movable types

---

## `std::type_index` (C++11)

```cpp []
///options+=-std=c++17
///hide
#include <string>
#include <unordered_map>
#include <typeinfo>
#include <iostream>
///unhide
#include <typeindex>

struct A {};

///hide
int main() {
///unhide
std::unordered_map<std::type_index, std::string> type_names{
  {std::type_index(typeid(int)),    "int"},
  {std::type_index(typeid(double)), "double"},
  {std::type_index(typeid(A)),      "A"}
};

int i;
double d;
A a;

std::cout << "i is " << type_names[std::type_index(typeid(i))] << '\n';
std::cout << "d is " << type_names[std::type_index(typeid(d))] << '\n';
std::cout << "a is " << type_names[std::type_index(typeid(a))] << '\n';
///hide
}
```

Note: The `type_index` class is a wrapper class around a `std::type_info` object, that can be used as index in associative containers.

---

## implementing event queue

```cpp [1,59|55-58|51-54|20-27|11-18|30-42|44-49|62-74]
///options+=-std=c++17 -pthread
///output=got int 42\ngot string hi
///hide
#include <any>
#include <chrono>
#include <functional>
#include <iostream>
#include <mutex>
#include <queue>
#include <thread>
#include <typeindex>
#include <unordered_map>
#include <condition_variable>

///unhide
class EventQueue {
 public:
  ~EventQueue() {
    {
      std::lock_guard<std::mutex> lg{mutex_};
      stop = true;
    }
    runner_.join();
  }

template <typename Data>
  void enqueue(Data&& data) {
    {
      std::lock_guard<std::mutex> lg{mutex_};
      queue_.emplace(std::type_index{typeid(Data)}, data);
    }
    cond_var_.notify_one();
  }

template <typename Data, typename Handler>
  void subscribe(Handler&& handler) {
    std::lock_guard<std::mutex> lg{mutex_};
    subscribers_.emplace(std::type_index{typeid(Data)},
      [h = std::forward<Handler>(handler)](std::any a) {
        std::forward<decltype(h)>(h)(std::any_cast<Data>(a));
      });
  }

private:
  void run() {
    do {
      std::unique_lock<std::mutex> ul{mutex_};
      cond_var_.wait(ul, [this] { 
        return stop || !queue_.empty(); 
      });
      while (!queue_.empty()) {
        auto& front = queue_.front();
        dispatch(front.first, front.second);
        queue_.pop();
      }
    } while (!stop);
  }

void dispatch(std::type_index index, std::any value) {
    auto rng = subscribers_.equal_range(index);
    for (auto it = rng.first; it != rng.second; ++it) {
      it->second(value);
    }
  }

std::thread runner_{[this] { run(); }};
  std::mutex mutex_;
  std::condition_variable cond_var_;
  bool stop = false;
  std::queue<std::pair<std::type_index, std::any>> queue_;
  std::unordered_multimap<std::type_index, 
                          std::function<void(const std::any&)>>
      subscribers_;
};

int main() { 
  using namespace std::literals;
  EventQueue eq;

eq.subscribe<int>([](int i) { 
    std::cout << "got int " << i << '\n'; 
  });

eq.subscribe<std::string>([](const std::string& s) { 
    std::cout << "got string " << s << '\n'; 
  });

eq.enqueue(42);
  eq.enqueue("hi"s);
}
```

---

## LEVEL 4

How many values?

```cpp
bool f(bool);
```

`$$ 4 $$`

```cpp
bool f1(bool b) { return b; }
bool f2(bool)   { return true; }
bool f3(bool)   { return false; }
bool f4(bool b) { return !b; }
```

---

## LEVEL 4

How many values?

```cpp
enum class Foo
{
  BAR,
  BAZ,
  QUUX
};
char f(Foo);
```

`$$ 256 \cdot 256 \cdot 256 = 16,777,216 $$`

---

## LEVEL 4

How many values?

```cpp
template <class T, class U>
U f(T);
```

`$$ |U|^{|T|} $$`

---

## functions

- The number of values of a function is the number of different ways we can draw arrows between the inputs and the outputs.
- When we have a function from `A` to `B`, we raise the # of inhabitants of `B` to the power of the # of inhabitants of `A`.

---

## LEVEL 5

How many values?

```cpp
///options+=-std=c++17 -fpermissive
///hide
#include <any>
///unhide
std::any;
```

`$$ \infty $$`

---

----

---

# `std::filesystem`

Sources:

- [P0218](https://wg21.link/p0218), Beman Dawes
 - [Boost.Filesystem](https://www.boost.org/doc/libs/1_75_0/libs/filesystem/doc/tutorial.html), Beman Dawes
 - [Mastering the C++17 STL](https://www.packtpub.com/product/mastering-the-c-17-stl/9781787126824), Arthur O'Dwyer

</div>

---

## a little refresher

![filesystem](15_filesystem/filesystem.png)

`/My Documents/speech.txt` → "Now is the time..."

`/alice-speech.txt` → "Now is the time..."

Note: the top level consists of abstract names which are mapped to concrete structures, called inodes in POSIX. each inode contains a set of attributes like size, owner, modification date, etc. and a pointer to the actual contents. The exact representation depends on the kind of file system, e.g. FAT32, ext4 or NTFS.

some blocks contain just mapping of names to inode numbers - these are directories. each file system has one special inode called the root directory. each file can be unambiguously identified by a path of names that leads from the root directory down to that file. for example, suppose that inode 2 is the root directory, then the path "/My Documents/speech.txt" points to the file containing "Now is the time...". We use slashes to compose these individual names into a single path, and we put a single slash on the front to indicate that we're starting from the root directory. When we access a file, the OS takes the path, splits it up at the slashes and descends into the directory structure of the file system until it finally reaches the inode of the requested file.

Alternatively, "/alice-speech.txt" is also a path leading from the root to inode 17. The two paths are 'hard links' to the same inode. This works like a ref-counted smart pointer, that is, a file is deleted only once all the hard links to it are deleted. For this reason, there's no point asking what is the name of a file as it can have multiple names.

---

## explicit typing

```cpp
///hide
#include <utility>
///unhide
std::pair<int, double> p{2, 4.5};
```

---

## not always possible to type

```cpp [1-12|16-21]
///hide
#include <algorithm>
#include <iostream>
#include <vector>
#include <functional>

using LAMBDA = std::function<void(int)>;

///unhide
template<typename Func>
struct Logger {
  Logger(Func f) : f_{f} {}

template<typename T>
  auto operator()(T&& t) {
    std::cout << "calling with " << t << '\n';
    return f(std::forward<T>(t));
  }

Func f_;
};

template<typename T>
void logged_print(const std::vector<T>& v) {
  std::for_each(v.begin(), v.end(), 
                Logger<LAMBDA>{[](const T& t) {
                    std::cout << t << ' ';
                  }
                }
  );
}

```

---

## make functions

```cpp
///hide 
#include <utility>
///unhide
auto p = std::make_pair(2, 4.5);
```

Note:

- Creating "make functions" like make_tuple is confusing, artificial, extra boilerplate, and inconsistent with how non-template classes are constructed.
- Since the standard library doesn't follow any consistent convention for make functions, users have to scurry through documentation to find they need to use `make_tuple` for tuples and `back_inserter` for `back_insert_iterator`s. Of course their own template classes might not be as consistent or thoroughly-documented as the standard.
- A make function may do more than just deduce constructor template arguments.

---

Source: [P0091](https://wg21.link/p0091), Mike Spertus, Faisal Vali, Richard Smith

## Class Template Argument Deduction

---

## CTAD

```cpp
///options+=-std=c++17
///hide
#include <utility>

#include <algorithm>
#include <iostream>
#include <vector>
#include <functional>

using LAMBDA = std::function<void(int)>;

template<typename Func>
struct Logger {
  Logger(Func f) : f_{f} {}

template<typename T>
  auto operator()(T&& t) {
    std::cout << "calling with " << t << '\n';
    return f(std::forward<T>(t));
  }

Func f_;
};
///unhide
std::pair p{2, 4.5};
static_assert(std::is_same_v<decltype(p), std::pair<int, double>>);

template<typename T>
void logged_print(const std::vector<T>& v) {
  std::for_each(v.begin(), v.end(), 
                Logger{[](const T& t) { std::cout << t << ' '; }});
}
```

---

## how does it work

```cpp
///options+=-std=c++17
template<typename T> struct UniquePtr {
  UniquePtr(T* t);
};

UniquePtr dp{new auto(2.0)};
```

compiler creates set of **deduction guides**:

```cpp []
///options+=-std=c++17
///hide
template<typename T> struct UniquePtr {
  UniquePtr(T* t);
};

///unhide
template<typename T> 
UniquePtr(UniquePtr<T> const&) -> UniquePtr<T>; // implicit copy ctor.
template<typename T> 
UniquePtr(UniquePtr<T> &&) -> UniquePtr<T>;     // implicit move ctor.
template<typename T> 
UniquePtr(T *p) -> UniquePtr<T>;                // user defined ctor.
```

</div>

```cpp [5-6]
///options+=-std=c++17
///hide
template<typename T> struct UniquePtr {
  UniquePtr(T* t);
};

</div>

and performs overload resolution

```cpp
///options+=-std=c++17
///hide
#include <type_traits>
template<typename T> struct UniquePtr {
  UniquePtr(T* t);
};

UniquePtr dp{new auto(2.0)};
///unhide
static_assert(std::is_same_v<decltype(dp), UniquePtr<double>>);
```

</div>

---

## another example

```cpp
///options+=-std=c++17
template<typename T> struct S {
  template<typename U> struct N {
    N(T);
    N(T, U);
    template<typename V> N(V, U);
  };
};

S<int>::N x{2.0, 1};
```

```cpp []
///options+=-std=c++17
///fails=error: invalid declarator before 'const'
///hide
template<typename T> struct S {
  template<typename U> struct N {
    N(T);
    N(T, U);
    template<typename V> N(V, U);
  };
};
///unhide
template<typename U> 
S<int>::N(S<int>::N<U> const&) -> S<int>::N<U>;
template<typename U> 
S<int>::N(S<int>::N<U> &&) -> S<int>::N<U>;
template<typename U> 
S<int>::N(int) -> S<int>::N<U>;
template<typename U>
S<int>::N(int, U) -> S<int>::N<U>;
template<typename U, typename V> 
S<int>::N(V, U) -> S<int>::N<U>;
```

</div>

```cpp [9-10]
///options+=-std=c++17
///fails=error: invalid declarator before 'const'
///hide
template<typename T> struct S {
  template<typename U> struct N {
    N(T);
    N(T, U);
    template<typename V> N(V, U);
  };
};
///unhide
template<typename U> 
S<int>::N(S<int>::N<U> const&) -> S<int>::N<U>;
template<typename U> 
S<int>::N(S<int>::N<U> &&) -> S<int>::N<U>;
template<typename U> 
S<int>::N(int) -> S<int>::N<U>;
template<typename U>
S<int>::N(int, U) -> S<int>::N<U>;
template<typename U, typename V> 
S<int>::N(V, U) -> S<int>::N<U>;
```

</div>

```cpp
///options+=-std=c++17
///hide
#include <type_traits>

template<typename T> struct S {
  template<typename U> struct N {
    N(T);
    N(T, U);
    template<typename V> N(V, U);
  };
};

S<int>::N x{2.0, 1};
///unhide
static_assert(std::is_same_v<decltype(x), S<int>::N<int>>);
```

</div>

Note: Template arguments can only be left out this way from the "type" of the declaration, but not from any name qualifiers used in naming the template; i.e., we couldn't replace `S<int>::N` by just `S::N` using some sort of additional level of deduction.

---

## hard to deduce

```cpp
///options+=-std=c++17
///fails=class template argument deduction failed
///hide
#include <cstddef>

///unhide
template<typename T>
class vector {
  struct iterator {
    using value_type = T;
    /* ... */
  };

using value_type = typename iterator::value_type;

vector(size_t count, const value_type& t = {});

template<typename InputIt>
  vector(InputIt from, InputIt to);
};

vector v1{5, 'c'};
vector v2{v1.begin(), v1.end()};
```

---

## explicit deduction guides

```cpp [16-21|23-26]
///options+=-std=c++17
///fails=class template argument deduction failed
///hide
#include <cstddef>
#include <type_traits>

template<typename It>
struct iterator_traits {
    using value_type = typename It::value_type;
};
 
///unhide
template<typename T>
struct vector {
  struct iterator {
    using value_type = T;
    /* ... */
  };
 
  using value_type = typename iterator::value_type;
 
  vector(size_t count, const value_type& t = {});
 
  template<typename InputIt>
  vector(InputIt from, InputIt to);
///hide

iterator begin();
  iterator end();
///unhide
};
 
template<typename T>
vector(size_t, T) -> vector<T>;
 
template<typename InputIt>
vector(InputIt, InputIt) -> 
  vector<typename iterator_traits<InputIt>::value_type>;
 
vector v1{5, 'c'};
static_assert(std::is_same_v<decltype(v1), vector<char>>);
vector v2{v1.begin(), v1.end()};
static_assert(std::is_same_v<decltype(v2), vector<char>>);
```

---

## note 1

```cpp
///options+=-std=c++17
///hide
#include <vector>
#include <type_traits>

///unhide
std::vector v1{'c'};
static_assert(std::is_same_v<decltype(v1), 
                             std::vector<char>>);

std::vector v2{'c', 'd'};
static_assert(std::is_same_v<decltype(v2), 
                             std::vector<char>>);

std::vector v3{v1};
static_assert(std::is_same_v<decltype(v3), 
                             std::vector<char>>);

std::vector v4{v1, v1};
static_assert(std::is_same_v<decltype(v4), 
                             std::vector<std::vector<char>>>);
```

---

## note 2

```cpp
///options+=-std=c++17
///hide
#include <vector>
#include <type_traits>

///unhide
std::vector v1(5, 'c');
static_assert(std::is_same_v<decltype(v1), 
                             std::vector<char>>);

std::vector v2{5, 'c'};
static_assert(std::is_same_v<decltype(v2), 
                             std::vector<char>>);

std::vector v3(v1.begin(), v1.end());
static_assert(std::is_same_v<decltype(v3), 
                             std::vector<char>>);

std::vector v4{v1.begin(), v1.end()};
static_assert(std::is_same_v<decltype(v4), 
                             std::vector<std::vector<char>::iterator>>);
```

---

## file size

```cpp [1-2|4-6|8-11]
///options+=-std=c++17
///hide
#include <iostream>
///unhide
#include <filesystem>
namespace fs = std::filesystem;

void print_file_size(const fs::path& p) {
  std::cout << p << " " << fs::file_size(p) << '\n';
}

int main()
{
  print_file_size(__FILE__);
}
```

Note: try 
  - non-existing file, like `"__FILE__"`
  - `"."`

---

## `fs::path`

```cpp
///hide
#include <string>

constexpr bool IsWindows = 
#ifdef _WIN32
true;
#else
false;
#endif

///unhide
class path {
  public:
    using value_type = std::conditional_t<
      IsWindows, wchar_t, char
    >;
    using string_type = std::basic_string<value_type>;

const auto& native() const { return m_path; }
    operator string_type() const { return m_path; }
    auto c_str() const { return m_path.c_str(); }

// many constructors and accessors omitted
  private:
    string_type m_path;
  };
```

Note: POSIX file systems store names as raw byte string while Windows uses UTF-16. The `path` class abstracts that away.

---

## checking before calling

```cpp []
///options+=-std=c++17
///hide
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

struct inaccessible_dir{
  inaccessible_dir() {
    fs::create_directory(PATH);
    fs::permissions(PATH, fs::perms::owner_write);
  }
  ~inaccessible_dir() {
    fs::remove_all(PATH);
  }
  constexpr static auto PATH = "/tmp/inaccessible";
} inaccessible;

///unhide
void print_file_size(const fs::path& p) {
  if (fs::exists(p)) {
    if (fs::is_regular_file(p)) {
      std::cout << p << " size is " << fs::file_size(p) << '\n';
    }
    else if (fs::is_directory(p)) {
      std::cout << p << " is a directory\n";
    }
    else {
      std::cout << p 
                << " exists, but is not a regular file or directory\n";
    }
  }
  else {
    std::cout << p << " does not exist\n";
  }
}

///hide
int main()
{
#if 0
  print_file_size(__FILE__);
#else
  print_file_size("/tmp/inaccessible/a");
#endif
}
```

---

## catching the error

```cpp [2,17-19]
///options+=-std=c++17
///hide
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

///unhide
void print_file_size(const fs::path& p) {
  try {
    if (fs::exists(p)) {
      if (fs::is_regular_file(p)) {
        std::cout << p << " size is " << fs::file_size(p) << '\n';
      }
      else if (fs::is_directory(p)) {
        std::cout << p << " is a directory\n";
      }
      else {
        std::cout << p << " exists, but is not a regular file or directory\n";
      }
    }
    else {
      std::cout << p << " does not exist\n";
    }
  } catch (const fs::filesystem_error& ex) {
    std::cerr << ex.what() << '\n';
  }
}

///hide
int main()
{
  print_file_size("/tmp/inaccessible/a");
}
```

---

## directory iterating

```cpp [7-12]
///options+=-std=c++17
///output="." is a directory containing
///hide
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

///unhide
void list(const fs::path& p) {
  try {
    if (fs::exists(p)) {
      if (fs::is_regular_file(p)) {
        std::cout << p << " size is " << fs::file_size(p) << '\n';
      }
      else if (fs::is_directory(p)) {
        std::cout << p << " is a directory containing:\n";

for (const fs::directory_entry& x : fs::directory_iterator{p})
          std::cout << "    " << x.path() << '\n';
      }
      else {
        std::cout << p 
                  << " exists, but is not a regular"
                  << " file or directory\n";
      }
    }
    else {
      std::cout << p << " does not exist\n";
    }
  } catch (const fs::filesystem_error& ex) {
    std::cerr << ex.what() << '\n';
  }
}

///hide
int main()
{
  list(".");
}
```

Note: ordering of directory iteration is unspecified

---

## sorted

```cpp [7-15]
///options+=-std=c++17
///output="." is a directory containing
///hide
#include <iostream>
#include <filesystem>
#include <vector>
#include <algorithm>
namespace fs = std::filesystem;

std::vector entries(fs::directory_iterator{p}, 
                            fs::directory_iterator{});
        std::sort(entries.begin(), entries.end());
        for (const auto& x : entries)
          std::cout << "    " << x.path().filename() << '\n';
      }
      else {
        std::cout << p 
                  << " exists, but is not a regular"
                  << " file or directory\n";
      }
    }
    else {
      std::cout << p << " does not exist\n";
    }
  } catch (const fs::filesystem_error& ex) {
    std::cerr << ex.what() << '\n';
  }
}

///hide
int main()
{
  list(".");
}
```

Note: using brace init with the vector would cause the compiler to deduce `std::vector<fs::directory_iterator>`

---

## recursive

```cpp [6]
///options+=-std=c++17
///hide
#include <fstream>
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;
 
int main()
{
///unhide
fs::current_path(fs::temp_directory_path());
fs::create_directories("sandbox/a/b");
std::ofstream("sandbox/file1.txt");
fs::create_symlink("a", "sandbox/syma");

for(auto& p: fs::recursive_directory_iterator("sandbox"))
    std::cout << p.path() << '\n';

fs::remove_all("sandbox");
///hide
}
```

Note: add `fs::directory_options::follow_directory_symlink`

---

## fold expressions

Source: [N4191](https://wg21.link/n4191), Andrew Sutton, Richard Smith

---

## variadic sum

instead of

```cpp [1-5]
template<typename T>
constexpr auto sum(T t) { return t; }

template<typename T, typename... Ts>
constexpr auto sum(T t, Ts... ts) { return t + sum(ts...); }

static_assert(sum(1, 2, 3) == 6);
```

write

```cpp [1-4]
///options+=-std=c++17
template<typename... Ts>
constexpr auto sum(Ts... ts) {
  return (ts + ...);
}

static_assert(sum(1, 2, 3) == 6);
```

</div>

Note: the parentheses

---

## comma operator too

```cpp
///hide
#include <iostream>

///unhide
template<typename T> 
void print(const T& x) { std::cout << x << '\n'; }

template<typename... Ts>
void for_each(const Ts&... args) {
  (print(args), ...);
}
```

---

## left vs right

left unary fold

`$$ (\ldots + args) => ((args_{0} + args_{1}) + \ldots) + args_{n} $$`

right unary fold

`$$ (args + \ldots) => args_{0} + (\ldots + (args_{n-1} + args_{n})) $$`

---

## empty packs

```cpp []
///options+=-std=c++17
///fails=fold of empty expansion over operator+
template<typename... Ts>
constexpr auto sum(Ts... ts) {
  return (ts + ...);
}

static_assert(sum() == 0);
```

---

## empty packs

```cpp []
///options+=-std=c++17
template<typename... Ts>
constexpr auto sum(Ts... ts) {
  return (ts + ... + 0);
}

static_assert(sum() == 0);
```

Note: assumes integral

---

## binary folds

left binary fold

`$$ (init + \ldots + args) => (((init + args_{0}) + args_{1}) + \ldots) + args_{n} $$`

right binary fold

`$$ (args + \ldots + init) => init + (args_{0} + (\ldots + (args_{n-1} + args_{n}))) $$`

---

## `&&`, `||`, `,`

```cpp []
///options+=-std=c++17
template<typename... Ts>
constexpr auto all_true(Ts... ts) {
  return (... && ts);
}

static_assert(all_true());
```

---

## path constructors

```cpp [2-3|5-17|19-21]
///options+=-std=c++17
///output="smiles" is a directory containing:\n    "smile"\n    "smile2"\n    "smile2☺"\n    "smile3"\n    "smile3☺"\n    "smile☺"
///hide
#include <iostream>
#include <filesystem>
#include <vector>
#include <algorithm>
#include <fstream>
#include <list>
namespace fs = std::filesystem;

void list(const fs::path& p) {
  try {
    if (fs::exists(p)) {
      if (fs::is_regular_file(p)) {
        std::cout << p << " size is " << fs::file_size(p) << '\n';
      }
      else if (fs::is_directory(p)) {
        std::cout << p << " is a directory containing:\n";

///unhide
int main() {
  fs::create_directory("smiles");
  fs::current_path("smiles");

std::string narrow_string ("smile2");
  std::u16string u16_string (u"smile2\u263A");
  std::list narrow_list{'s', 'm', 'i', 'l', 'e', '3'};
  std::list u16_list{u's', u'm', u'i', u'l', u'e', u'3', u'\u263A'};
  
  { std::ofstream f(fs::path{"smile"}); }
  { std::ofstream f(fs::path{u"smile\u263A"}); }
  { std::ofstream f(fs::path{narrow_string}); }
  { std::ofstream f(fs::path{u16_string}); }
  { std::ofstream f(fs::path{narrow_list.begin(), 
                             narrow_list.end()}); }
  { std::ofstream f(fs::path{u16_list.begin(), 
                             u16_list.end()}); }
  
  fs::current_path("..");
  list("smiles");
  fs::remove_all("smiles");
}
```

---

## path methods

```c++
///options+=-std=c++17
///hide
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

///unhide
template<typename... Parts>
void path_info(Parts&&... parts) {
  using std::cout;
  using std::wcout;

auto p = (fs::path{parts} / ...);

cout  <<  "\ncomposed path:\n";
  cout  <<  "  operator<<()---------: " << p << '\n';
  cout  <<  "  make_preferred()-----: " << p.make_preferred() << '\n';

cout << "\nelements:\n";
  for (const auto& element : p)
    cout << "  " << element << '\n';

cout  <<  "\nobservers, native format:\n";
#ifndef _WIN32
  cout  <<  "  native()-------------: " << p.native()   << '\n';
  cout  <<  "  c_str()--------------: " << p.c_str()    << '\n';
#else
  wcout << L"  native()-------------: " << p.native()   << '\n';
  wcout << L"  c_str()--------------: " << p.c_str()    << '\n';
#endif
  cout  <<  "  string()-------------: " << p.string()   << '\n';
  wcout << L"  wstring()------------: " << p.wstring()  << '\n';

cout  <<  "\nobservers, generic format:\n";
  cout  <<  "  generic_string()-----: " << p.generic_string()   << '\n';
  wcout << L"  generic_wstring()----: " << p.generic_wstring()  << '\n';

cout  <<  "\ndecomposition:\n";
  cout  <<  "  root_name()----------: " << p.root_name()      << '\n';
  cout  <<  "  root_directory()-----: " << p.root_directory() << '\n';
  cout  <<  "  root_path()----------: " << p.root_path()      << '\n';
  cout  <<  "  relative_path()------: " << p.relative_path()  << '\n';
  cout  <<  "  parent_path()--------: " << p.parent_path()    << '\n';
  cout  <<  "  filename()-----------: " << p.filename()       << '\n';
  cout  <<  "  stem()---------------: " << p.stem()           << '\n';
  cout  <<  "  extension()----------: " << p.extension()      << '\n';

cout  <<  "\nquery:\n" << std::boolalpha;
  cout  <<  "  empty()--------------: " << p.empty()              << '\n';
  cout  <<  "  is_absolute()--------: " << p.is_absolute()        << '\n';
  cout  <<  "  has_root_name()------: " << p.has_root_name()      << '\n';
  cout  <<  "  has_root_directory()-: " << p.has_root_directory() << '\n';
  cout  <<  "  has_root_path()------: " << p.has_root_path()      << '\n';
  cout  <<  "  has_relative_path()--: " << p.has_relative_path()  << '\n';
  cout  <<  "  has_parent_path()----: " << p.has_parent_path()    << '\n';
  cout  <<  "  has_filename()-------: " << p.has_filename()       << '\n';
  cout  <<  "  has_stem()-----------: " << p.has_stem()           << '\n';
  cout  <<  "  has_extension()------: " << p.has_extension()      << '\n';
}

int main()
{
  path_info("/foo", "bar", "baa.txt");
}
```

Note: see Windows at https://rextester.com/FQY15022, note that the path is not absolute there

---

## catching the error, again

```cpp [2,17-19]
///options+=-std=c++17
///hide
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

///hide
int main()
{
  print_file_size("/tmp/inaccessible/a");
}
```

---

## using error codes

```cpp [2-20]
///options+=-std=c++17
///hide
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;

///unhide
void print_file_size(const fs::path& p) {
  std::error_code ec;
  if (fs::exists(p, ec) && !ec) {
    if (fs::is_regular_file(p, ec) && !ec) {
      std::cout << p << " size is " << fs::file_size(p, ec) << '\n';
    }
    else if (fs::is_directory(p, ec) && !ec) {
      std::cout << p << " is a directory\n";
    }
    else if (!ec) {
      std::cout << p << " exists, but is not a regular file or directory\n";
    }
  }
  else if (!ec) {
    std::cout << p << " does not exist\n";
  }
  if (ec) {
    auto err_cond = std::system_category().default_error_condition(ec.value());
    std::cerr << err_cond.message() << ": " << p << '\n';
  }
}

///hide
int main()
{
  print_file_size("/tmp/inaccessible/a");
}
```

---

## `std::filesystem::perms`

| Member constant | Value (octal) | POSIX equivalent | Meaning |
|-----------------|---------------|------------------|---------|
| `none` | `0` | | no permission bits are set |
| `owner_read` | `0400` | `S_IRUSR` | File owner has read permission |
| `owner_write` | `0200` | `S_IWUSR` | File owner has write permission |
| `owner_exec` | `0100` | `S_IXUSR` | File owner has execute/search permission |
| `owner_all` | `0700` | `S_IRWXU` | File owner has read, write, and execute/search permissions Equivalent to `owner_read \| owner_write \| owner_exec` |
| `group_read` | `040` | `S_IRGRP` | The file's user group has read permission |
| `group_write` | `020` | `S_IWGRP` | The file's user group has write permission |
| `group_exec` | `010` | `S_IXGRP` | The file's user group has execute/search permission |
| `group_all` | `070` | `S_IRWXG` | The file's user group has read, write, and execute/search permissions Equivalent to `group_read | group_write | group_exec` |
| `others_read` | `04` | `S_IROTH` | Other users have read permission |
| `others_write` | `02` | `S_IWOTH` | Other users have write permission |
| `others_exec` | `01` | `S_IXOTH` | Other users have execute/search permission |
| `others_all` | `07` | `S_IRWXO` | Other users have read, write, and execute/search permissions Equivalent to `others_read \| others_write \| others_exec` |
| `all` | `0777` | | All users have read, write, and execute/search permissions Equivalent to `owner_all \| group_all \| others_all` |
| `set_uid` | `04000` | `S_ISUID` | Set user ID to file owner user ID on execution |
| `set_gid` | `02000` | `S_ISGID` | Set group ID to file's user group ID on execution |
| `sticky_bit` | `01000` | `S_ISVTX` | Implementation-defined meaning, but POSIX XSI specifies that when set on a directory, only file owners may delete files even if the directory is writeable to others (used with `/tmp`) |
| `mask` | `07777` | | All valid permission bits. Equivalent to `all \| set_uid \| set_gid \| sticky_bit` |

---

## permissions

```cpp [1-13|17-29]
///options+=-std=c++17
///hide
///output=Created file with permissions: rw-rw-r--\nAfter adding u+rwx and g+rwx:  rwxrwxr--
#include <fstream>
#include <bitset>
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;
 
///unhide
void show_perms(fs::perms p)
{
  std::cout << ((p & fs::perms::owner_read) != fs::perms::none ? "r" : "-")
            << ((p & fs::perms::owner_write) != fs::perms::none ? "w" : "-")
            << ((p & fs::perms::owner_exec) != fs::perms::none ? "x" : "-")
            << ((p & fs::perms::group_read) != fs::perms::none ? "r" : "-")
            << ((p & fs::perms::group_write) != fs::perms::none ? "w" : "-")
            << ((p & fs::perms::group_exec) != fs::perms::none ? "x" : "-")
            << ((p & fs::perms::others_read) != fs::perms::none ? "r" : "-")
            << ((p & fs::perms::others_write) != fs::perms::none ? "w" : "-")
            << ((p & fs::perms::others_exec) != fs::perms::none ? "x" : "-")
            << '\n';
}

int main()
{
  std::ofstream("test.txt"); // create file

std::cout << "Created file with permissions: ";
  show_perms(fs::status("test.txt").permissions());

fs::permissions("test.txt",
                  fs::perms::owner_all | fs::perms::group_all,
                  fs::perm_options::add);

std::cout << "After adding u+rwx and g+rwx:  ";
  show_perms(fs::status("test.txt").permissions());

fs::remove("test.txt");
}
```

Note: there's also `fs::perm_options::replace` and `fs::perm_options::remove`

---

## query free space

```cpp [1-2,8-9,11-12]
///options+=-std=c++17
///hide
#include <iostream>
#include <filesystem>
namespace fs = std::filesystem;
int main()
{
///unhide
fs::space_info devi = fs::space("/dev/null");
fs::space_info tmpi = fs::space("/tmp");

std::cout << std::setw(6) << std::left << "." << std::right << std::setw(15) 
          << "Capacity" << std::setw(15) << "Free" << std::setw(15) 
          << "Available" << '\n'
          << std::setw(6) << std::left << "/dev:" << std::right << std::setw(15) 
          << devi.capacity << std::setw(15) << devi.free << std::setw(15) 
          << devi.available << '\n'
          << std::setw(6) << std::left << "/tmp:" << std::right << std::setw(15) 
          << tmpi.capacity << std::setw(15) << tmpi.free << std::setw(15) 
          << tmpi.available  << '\n';
///unhide
}
```

---