### TypedInPlaceFactory Implementation

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/in_place_factories.html

Example implementation of a TypedInPlaceFactory class that encapsulates constructor parameters for a specific type.

```cpp
template<class T,class A0, class A1>
class TypedInPlaceFactory2
{
    A0 m_a0 ; A1 m_a1 ;

    public:

    TypedInPlaceFactory2( A0 const& a0, A1 const& a1 ) : m_a0(a0), m_a1(a1) {}

    void construct ( void* p ) { new (p) T(m_a0,m_a1) ; }
 } ;
```

--------------------------------

### Indeterminate Value Example

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/optional/design.html

Demonstrates the creation of an automatic object with an indeterminate value, which leads to undefined or erroneous behavior if read before assignment.

```cpp
{
  int i; // indeterminate value
  populate(&i);
  cout << i;
}
```

--------------------------------

### Member Functions for optional<T&>

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_references.html

Details on member functions like emplace, get, operator*, and operator->.

```APIDOC
## Member Functions for optional<T&>

### `emplace`

```cpp
void optional<T&>::emplace( R&& r ) noexcept ;
```

*   **Effects:** Assigns `ref` with expression `r`.
*   **Postconditions:** `bool(*this) == true`.
*   **Remarks:** Unless `R` is an lvalue reference, the program is ill-formed. This function does not participate in overload resolution if `decay<R>` is an instance of `boost::optional`.

### Dereference Operators (`get`, `operator*`)

```cpp
T& optional<T&>::get() const ;
T& optional<T&>::operator *() const ;
```

*   **Requires:** `bool(*this) == true`.
*   **Effects:** Returns `*ref`.
*   **Throws:** Nothing.
*   **Example:**
    ```cpp
    T v;
    T& vref = v;
    optional<T&> opt ( vref );
    T const& vref2 = *opt;
    assert ( vref2 == v );
    ++ v;
    assert ( *opt == v );
    ```

### Arrow Operator (`operator->`)

```cpp
T* optional<T&>::operator -> () const ;
```

*   **Requires:** `bool(*this) == true`.
*   **Effects:** Returns `ref`.
*   **Throws:** Nothing.

### `value`

```cpp
T& optional<T&>::value() const ;
```
```

--------------------------------

### std::optional Static Assertion Example

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/convenience_conversions_and_deductions.html

Uses a static assertion to check the equality comparability between std::optional and a non-optional type, highlighting potential concept-related issues.

```cpp
static_assert(std::equality_comparable_with<std::optional<Threshold>, Threshold>);
```

--------------------------------

### Assigning to Uninitialized Optional Reference

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/optional_references/rebinding_semantics_for_assignment_of_optional_references.html

When assigning to an uninitialized `optional<T&>`, it binds to the object for the first time. This example shows the initial binding and subsequent modification of the referenced object.

```cpp
int x = 1 ;
int& rx = x ;
optional<int&> ora ;
optional<int&> orb(x) ;
ora = orb ; // now 'ora' is bound to 'x' through 'rx'
*ora = 2 ; // Changes value of 'x' through 'ora'
assert(x==2);
```

--------------------------------

### Using boost::optional for Configuration Parameters

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/index.html

Demonstrates how to handle optional configuration values that may or may not be present, avoiding the need for sentinel values.

```cpp
#include <boost/optional.hpp>

boost::optional<int> getConfigParam(std::string name);  // return either an int or a `not-an-int`

int main()
{
  if (boost::optional<int> oi = getConfigParam("MaxValue")) // did I get a real int?
    runWithMax(*oi);                                        // use my int
  else
    runWithNoMax();
}
```

--------------------------------

### No-Value Initialization: Boost vs. Std

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/std_comp.html

Demonstrates the different ways to initialize an optional with no value in Boost.Optional and std::optional.

```cpp
optional<int> o = none;
```

```cpp
optional<int> o = nullopt;
```

--------------------------------

### Using IO operators with boost::optional

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/io_operators.html

Demonstrates basic input and output operations for optional types. Requires including the boost/optional/optional_io.hpp header.

```cpp
#include <iostream>
#include <boost/optional/optional_io.hpp>

int main()
{
  boost::optional<int> o1 = 1, oN = boost::none;
  std::cout << o1;
  std::cin >> oN;
}
```

--------------------------------

### Get pointer to optional value

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___free_functions.html

Returns a pointer to the contained value of an optional. Throws no exceptions.

```cpp
auto get_pointer ( optional<T>& o ) -> typename optional<T>::pointer_type ;
auto get_pointer ( optional<T> const& o ) -> typename optional<T>::pointer_const_type ;

```

--------------------------------

### Get optional value or default

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___free_functions.html

Returns the contained value of an optional or a default value if the optional is uninitialized. This function is deprecated.

```cpp
auto get_optional_value_or ( optional<T>& o, typename optional<T>::reference_type def ) -> typename optional<T>::reference_type ;
auto get_optional_value_or ( optional<T> const& o, typename optional<T>::reference_const_type def ) -> typename optional<T>::reference_const_type ;

```

--------------------------------

### Initialize and Assign Optional Objects

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/iface.html

Demonstrates how to construct and assign values to optional objects, including the use of the none tag.

```cpp
optional<int> o1;        // contains no value
optional<int> o2 = 2;    // contains value 2
optional<int> o3 = none; // contains no value

o1 = 1;    // assign value 1
o2 = none; // assign a no-value
o3 = {};   // assign a no-value
```

--------------------------------

### Boost.Optional Explicit Operations

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/convenience_conversions_and_deductions.html

Demonstrates the explicit and verbose syntax recommended by Boost.Optional for operations like creating an optional or comparing values, ensuring clarity and preventing silent bugs.

```cpp
Threshold th;
auto o = boost::make_potional(th);   // *always* add a new layer of optionality

return boost::equal_pointees(o, th); // *always* unpack optionals for comparison
return o && *o == th;    // *always* treat the right-hand side argument as value
```

--------------------------------

### Getting optional<T&> value or a fallback (deprecated)

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_references.html

Retrieves the contained reference or a fallback value if the optional is empty. This function is deprecated and is equivalent to `value_or`.

```cpp
template<class R>
T& optional<T&>::get_value_or( R&& r ) const noexcept;

```

--------------------------------

### Standard Wrapper Construction

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/in_place_factories.html

Demonstrates the standard approach of initializing a wrapped object via a copy constructor, which requires a temporary object.

```cpp
struct X
{
    X ( int, std::string ) ;
} ;

class W
{
    X wrapped_ ;

    public:

    W ( X const& x ) : wrapped_(x) {}
} ;

void foo()
{
    // Temporary object created.
    W ( X(123,"hello") ) ;
}
```

--------------------------------

### In-Place Initialization: Boost vs. Std

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/std_comp.html

Compares the syntax for in-place initialization of optional types with constructor arguments.

```cpp
optional<X> o {in_place_init, a, b};
```

```cpp
optional<int> o {in_place, a, b};
```

--------------------------------

### Accessing optional<T&> value with a function fallback

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_references.html

Use this to get the contained reference or the result of a function call if the optional is empty. The function is called only if the optional is empty.

```cpp
template<class F>
T& optional<T&>::value_or( F f ) const ;

```

--------------------------------

### Initialize and Assign optional<T> with std::move

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_values.html

Demonstrates initialization and assignment using `std::move` for `boost::optional<T>`. Ensure `T` is `MoveConstructible` and `MoveAssignable`.

```cpp
T x;
optional<T> def ;
optional<T> opt(x) ;

T y1, y2, yR;
def = std::move(y1) ;
assert ( *def == yR ) ;
opt = std::move(y2) ;
assert ( *opt == yR ) ;

```

--------------------------------

### Basic Optional Initialization

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_values.html

Initializes an optional object and verifies its state.

```cpp
optional<int> y(x) ;
assert( *y == 123 ) ;
```

--------------------------------

### Getting a pointer to the contained reference

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_references.html

Returns a pointer to the contained reference if the optional has a value, otherwise returns nullptr. This is a safe way to access the reference without exceptions.

```cpp
T* optional<T&>::get_ptr () const noexcept;

```

--------------------------------

### Optional References: Boost vs. Std

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/std_comp.html

Demonstrates that Boost.Optional supports optional references, a feature not available in std::optional.

```cpp
optional<X const&> o;
```

--------------------------------

### Generic In-Place Factory Usage

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/in_place_factories.html

Shows how a wrapper can use a generic InPlaceFactory to construct an object in-place.

```cpp
class W
{
    X wrapped_ ;

    public:

    W ( X const& x ) : wrapped_(x) {}

    template< class InPlaceFactory >
    W ( InPlaceFactory const& fac ) { fac.template <X>construct(&wrapped_) ; }

} ;

void foo()
{
    // Wrapped object constructed in-place via a InPlaceFactory.
    // No temporary created.
    W ( in_place(123,"hello") ) ;
}
```

--------------------------------

### Accessing optional<T&> value or returning a fallback

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_references.html

Use this to get the contained reference or a provided fallback value if the optional is empty. The fallback value is returned by copy or move.

```cpp
template<class R>
T& optional<T&>::value_or( R&& r ) const noexcept;

```

--------------------------------

### Safely Extract Value with Assertion

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/quick_overview.html

When you are certain a string converts to a valid integer, you can directly dereference the result of convert. This example uses BOOST_ASSERT to guard against potential undefined behavior.

```cpp
int i = *convert("100");

```

--------------------------------

### In-Place Initialization with Initializer List: Boost vs. Std

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/std_comp.html

Highlights that std::optional supports in-place initialization with an initializer list, while Boost.Optional does not.

```cpp
optional<vector<int>> o {in_place, {1, 2, 3}};
o.emplace({4, 5, 6});
```

--------------------------------

### Basic optional<T> Usage

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/type_requirements.html

Demonstrates the basic initialization and checking of an uninitialized optional object. Accessing the value of an uninitialized optional will always throw.

```cpp
optional<T> o;     // uninitialized
assert(o == none); // check if initialized
assert(!o);        //
o.value();         // always throws
```

--------------------------------

### Extract Optional Value or Evaluate Callback

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/quick_overview.html

Use .value_or_eval(callback) to get the contained value or execute a provided callback function if the optional is uninitialized. The callback's return value is then used.

```cpp
int fallback_to_default()
{
  cerr << "could not convert; using -1 instead" << endl;
  return -1;
}

int l = convert(text).value_or_eval(fallback_to_default);

```

--------------------------------

### Wrapper Using TypedInPlaceFactory

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/in_place_factories.html

Demonstrates a wrapper class designed to accept a TypedInPlaceFactory to construct its internal object.

```cpp
class W
{
    X wrapped_ ;

    public:

    W ( X const& x ) : wrapped_(x) {}
    W ( TypedInPlaceFactory2 const& fac ) { fac.construct(&wrapped_) ; }
} ;

void foo()
{
    // Wrapped object constructed in-place via a TypedInPlaceFactory.
    // No temporary created.
    W ( TypedInPlaceFactory2<X,int,std::string>(123,"hello")) ;
}
```

--------------------------------

### Rebinding Initialized Optional Reference

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/optional_references/rebinding_semantics_for_assignment_of_optional_references.html

Assigning to an initialized `optional<T&>` rebinds it to the new object, unlike bare C++ references. This example shows how `ora` is rebound to `b` and subsequent modifications affect `b`.

```cpp
int a = 1 ;
int b = 2 ;
int& ra = a ;
int& rb = b ;
optional<int&> ora(ra) ;
optional<int&> orb(rb) ;
ora = orb ; // 'ora' is rebound to 'b'
*ora = 3 ; // Changes value of 'b' (not 'a')
assert(a==1);
assert(b==3);
```

--------------------------------

### Assigning to Bare C++ Reference

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/optional_references/rebinding_semantics_for_assignment_of_optional_references.html

Assigning to a bare C++ reference forwards the assignment to the referenced object, changing its value but not rebinding the reference itself. This example demonstrates that the reference remains bound to the original object.

```cpp
int a = 1 ;
int& ra = a ;
int b = 2 ;
int& rb = b ;
ra = rb ; // Changes the value of 'a' to 'b'
assert(a==b);
b = 3 ;
assert(ra!=b); // 'ra' is not rebound to 'b'
```

--------------------------------

### Move-Constructing an Optional

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_values.html

Demonstrates move-constructing an optional from another optional.

```cpp
optional<double> x(123.4);
assert ( *x == 123.4 ) ;

optional<int> y(std::move(x)) ;
assert( *y == 123 ) ;
```

--------------------------------

### Compare optional objects

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/relational_operators.html

Demonstrates equality comparisons between optional objects and the uninitialized state.

```cpp
boost::optional<int> oN = boost::none;
boost::optional<int> o0 = 0;
boost::optional<int> o1 = 1;

assert(oN != o0);
assert(o1 != oN);
assert(o0 != o1);
assert(oN == oN);
assert(o0 == o0);
```

--------------------------------

### Optional<T&> Specialization for Lvalue References

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header_optional_optional_refs.html

This code defines the `optional<T&>` class template, a specialization for handling lvalue references. It includes constructors, assignment operators, and member functions like `get()`, `operator*()`, `operator->()`, `value()`, `value_or()`, `map()`, `flat_map()`, `get_ptr()`, `has_value()`, `operator bool()`, `operator!()`, and `reset()`. Deprecated methods are also listed.

```cpp
template <class T>
class optional<T&> // specialization for lvalue references
{
public :

    typedef T& value_type;
    typedef T& reference_type;
    typedef T& reference_const_type; // no const propagation
    typedef T& rval_reference_type;
    typedef T* pointer_type;
    typedef T* pointer_const_type;   // no const propagation

    optional () noexcept ;

    optional ( none_t ) noexcept ;

    template<class R> optional(R&& r) noexcept ;

    template <class R> optional(bool cond, R&& r) noexcept ;

    optional ( optional const& rhs ) noexcept ;

    template<class U> explicit optional ( optional<U&> const& rhs ) noexcept ;

    optional& operator = ( none_t ) noexcept ;

    optional& operator = ( optional const& rhs ) noexcept;

    template<class U> optional& operator = ( optional<U&> const& rhs ) noexcept ;

    template<class R> optional& operator = (R&& r) noexcept ;

    template<class R> void emplace ( R&& r ) noexcept ;

    T& get() const ;
    T& operator *() const ;

    T* operator ->() const ;

    T& value() const& ;

    template<class R> T& value_or( R && r ) const noexcept ;

    template<class F> T& value_or_eval( F f ) const ;

    template<class F> auto map( F f ) const -> _see below_;

    template<class F> auto flat_map( F f ) const -> _see below_;

    T* get_ptr() const noexcept ;

    bool has_value() const noexcept ;

    explicit operator bool() const noexcept ;

    bool operator!() const noexcept ;

    void reset() noexcept ;

    // deprecated methods

    // (deprecated)
    template<class R> void reset ( R && r ) noexcept ;

    // (deprecated)
    bool is_initialized() const noexcept ;

    // (deprecated)
    template<class R> T& get_value_or( R && r ) constnoexcept;

private:
    T* ref; // exposition only
};

```

--------------------------------

### std::optional Convenience Conversions

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/convenience_conversions_and_deductions.html

Demonstrates implicit conversions and comparisons that std::optional supports, which can sometimes lead to unexpected behavior.

```cpp
std::optional oi = 1;                 // OK

std:string_view sv = "hi";
std::optional<std::string> os = sv;   // OK
os == sv;                             // OK

std::optional<std::string> osv;
std::optional<std::string> os2 = osv; // OK
os2 == osv;                           // OK
```

--------------------------------

### Compare optional with values

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/relational_operators.html

Demonstrates mixed comparisons between optional objects and raw values or boost::none.

```cpp
assert(oN != 0);
assert(o1 != boost::none);
assert(o0 != 1);
assert(oN == boost::none);
assert(o0 == 0);
```

--------------------------------

### Using the negation operator for optional<T>

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_values.html

Demonstrates checking the initialization state of an optional object using the negation operator and the double-bang idiom.

```cpp
optional<T> opt ;
assert ( !opt );
*opt = some_T ;

// Notice the "double-bang" idiom here.
assert ( !!opt ) ;
```

--------------------------------

### Forward declarations for boost::optional

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_fwd_hpp_.html

Contains the namespace declarations for the optional class template and swap utility.

```cpp
namespace boost {

template <class T> class optional ;

template <class T> void swap ( optional<T>& , optional<T>& );

template <class T> struct optional_swap_should_use_default_constructor ;

} // namespace boost
```

--------------------------------

### Lazy Load Optimization with Boost.Optional

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/quick_overview/optional_data_members.html

Demonstrates lazy initialization of a `Resource` member using `boost::optional`. The `emplace` function is used to initialize the optional in-place, avoiding copy or move constructions. This is useful when resource initialization is expensive and may not always be required.

```cpp
class Widget
{
  mutable boost::optional<const Resource> resource_;

public:
  Widget() {}

  const Resource& getResource() const // not thread-safe
  {
    if (resource_ == boost::none)
        resource_.emplace("resource", "arguments");

    return *resource_;
  }
};

```

--------------------------------

### Initialize and Check Optional in One Step

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/quick_overview.html

Combine the initialization of a boost::optional object and the check for its value into a single 'if' statement for concise code.

```cpp
if (boost::optional<int> oi = convert(text))
  int i = *oi;

```

--------------------------------

### Printing to IOStreams: Boost vs. Std

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/std_comp.html

Demonstrates that Boost.Optional supports direct printing to IOStreams, a capability not present in std::optional.

```cpp
std::cout << optional<int>{};
```

--------------------------------

### Handling optional user input

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/optional/advice.html

Demonstrates using optional<string> to handle user input where an empty string might signify missing text, allowing for a dedicated program path. This pattern requires translating empty strings to a state with no contained value within the function returning the optional.

```cpp
if(boost::optional<std::string> name = ask_user_name()) {
    assert(*name != "");
    logon_as(*name);
}
else {
    skip_logon();
}
```

--------------------------------

### Boost Optional Usage with GCC -Wmaybe-uninitialized Warning

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/gotchas/false_positive_with__wmaybe_uninitialized.html

This code demonstrates a scenario where GCC compilers below version 5.1 might issue an -Wmaybe-uninitialized warning with boost::optional, even with valid usage. It's recommended to use the workaround provided in the documentation if this warning appears.

```cpp
#include <boost/optional.hpp>

boost::optional<int> getitem();

int main(int argc, const char *[])
{
  boost::optional<int> a = getitem();
  boost::optional<int> b;

  if (argc > 0)
    b = argc;

  if (a != b)
    return 1;

  return 0;
}

```

--------------------------------

### Implement convert function with boost::optional

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/quick_overview/optional_automatic_variables.html

Demonstrates a function that returns an optional integer, ensuring a single return statement and well-defined state.

```cpp
boost::optional<int> convert(const std::string& text)
{
  boost::optional<int> ans;
  std::stringstream s(text);
  int i;
  if ((s >> i) && s.get() == std::char_traits<char>::eof())
    ans = i;

  return ans;
}
```

--------------------------------

### Portable Optional Reference Initialization

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/dependencies_and_portability/optional_reference_binding.html

Use direct-initialization and explicit construction to ensure portability across compilers that handle reference binding differently.

```cpp
const int i = 0;
optional<const int&> or1;
optional<const int&> or2 = i;  // caution: not portable
or1 = i;                       // caution: not portable

optional<const int&> or3(i);   // portable
or1 = optional<const int&>(i); // portable
```

--------------------------------

### Conditional Initialization from T: Boost vs. Std

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/std_comp.html

Illustrates that Boost.Optional supports conditional initialization from a value of type T, a feature absent in std::optional.

```cpp
optional<X> o {cond, x};
```

--------------------------------

### Constructors for optional<T&>

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_references.html

Details on how to construct optional references.

```APIDOC
## Constructors for optional<T&>

### Default Constructor

```cpp
optional<T&>::optional() noexcept;
optional<T&>::optional(none_t) noexcept;
```

*   **Postconditions:** `bool(*this) == false`; `*this` refers to nothing.

### Initializing with a Reference

```cpp
template<class R> optional<T&>::optional(R&& r) noexcept;
```

*   **Postconditions:** `bool(*this) == true`; `addressof(**this) == addressof(r)`.
*   **Remarks:** Unless `R` is an lvalue reference, the program is ill-formed. This constructor does not participate in overload resolution if `decay<R>` is an instance of `boost::optional`.
*   **Notes:** This constructor is declared `explicit` on compilers that do not correctly support binding to const lvalues of integral types.
*   **Example:**
    ```cpp
    T v;
    T& vref = v;
    optional<T&> opt(vref);
    assert ( *opt == v );
    ++ v; // mutate referee
    assert (*opt == v);
    ```

### Initializing with a Conditional Reference

```cpp
template<class R> optional<T&>::optional(bool cond, R&& r) noexcept;
```

*   **Effects:** Initializes `ref` with expression `cond ? addressof(r) : nullptr`.
*   **Postconditions:** `bool(*this) == cond`; If `bool(*this)`, `addressof(**this) == addressof(r)`.
*   **Remarks:** Unless `R` is an lvalue reference, the program is ill-formed. This constructor does not participate in overload resolution if `decay<R>` is an instance of `boost::optional`.

### Copy Constructor

```cpp
optional<T&>::optional ( optional const& rhs ) noexcept ;
```

*   **Effects:** Initializes `ref` with expression `rhs.ref`.
*   **Postconditions:** `bool(*this) == bool(rhs)`.
*   **Example:**
    ```cpp
    optional<T&> uninit;
    assert (!uninit);

    optional<T&> uinit2 ( uninit );
    assert ( uinit2 == uninit );

    T v = 2;
    T& ref = v;
    optional<T> init(ref);
    assert ( *init == v );

    optional<T> init2 ( init );
    assert ( *init2 == v );

    v = 3;

    assert ( *init  == 3 );
    assert ( *init2 == 3 );
    ```

### Converting Copy Constructor

```cpp
template<class U> explicit optional<T&>::optional ( optional<U&> const& rhs ) noexcept ;
```

*   **Requires:** `is_convertible<U&, T&>::value` is `true`.
*   **Effects:** Initializes `ref` with expression `rhs.ref`.
*   **Postconditions:** `bool(*this) == bool(rhs)`.
```

--------------------------------

### Initializing optional<T> with emplace()

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/type_requirements.html

Shows how to initialize an optional object using the `emplace()` function when the contained type `T` has an accessible constructor. This is an alternative to In-Place Factories if compiler support is limited.

```cpp
optional<T> o;
o.emplace("T", "ctor", "params");
```

--------------------------------

### Conditional In-Place Initialization: Boost vs. Std

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/std_comp.html

Shows that Boost.Optional has a syntax for conditional in-place initialization, which is not present in std::optional.

```cpp
optional<X> o {in_place_init_if, cond, a, b};
```

--------------------------------

### Comparison Behaviors of optional<bool>

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/gotchas.html

Illustrates how mixed comparisons between optional<bool> and bool values can produce unexpected results compared to standard boolean logic.

```cpp
optional<bool> oEmpty(none), oTrue(true), oFalse(false);

if (oEmpty == none);  // renders true
if (oEmpty == false); // renders false!
if (oEmpty == true);  // renders false

if (oFalse == none);  // renders false
if (oFalse == false); // renders true!
if (oFalse == true);  // renders false

if (oTrue == none);   // renders false
if (oTrue == false);  // renders false
if (oTrue == true);   // renders true
```

--------------------------------

### Constructors from U and optional<U>: Boost vs. Std

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/std_comp.html

Compares the explicitness of constructors for optional types when initializing from another type U or an optional of U.

```cpp
optional<T> o {U{}};
optional<T> o {optional<U>{}};
```

```cpp
optional<T> o = U{};
optional<T> o = optional<U>{}
```

--------------------------------

### Boost.Optional Header Synopsis

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/optional/reference/header__boost_optional_optional_hpp_.html

This snippet provides a synopsis of the <boost/optional/optional.hpp> header, outlining the classes, functions, and operators available for use with Boost.Optional.

```APIDOC
## Header <boost/optional/optional.hpp>

### Description
This header provides the `boost::optional` class template and related functionalities for handling values that may or may not be present.

### Synopsis
```cpp // In Header: <boost/optional/optional.hpp>

namespace boost {

class in_place_init_t { /* see below */ } ;
inline constexpr in_place_init_t in_place_init ( /* see below */ ) ;

class in_place_init_if_t { /*see below*/ } ;
inline constexpr in_place_init_if_t in_place_init_if ( /*see below*/ ) ;

template <class T>
class optional ;

template <class T>
class optional<T&> ;

template<class T> inline bool operator == ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator != ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator <  ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator >  ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator <= ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator >= ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator == ( optional<T> const& x, none_t ) noexcept ;

template<class T> inline bool operator != ( optional<T> const& x, none_t ) noexcept ;

template<class T> inline optional<T> make_optional ( T const& v ) ;

template<class T> inline optional<std::decay_t<T>> make_optional ( T && v ) ;

template<class T> inline optional<T> make_optional ( bool condition, T const& v ) ;

template<class T> inline optional<std::decay_t<T>> make_optional ( bool condition, T && v ) ;

template<class T> inline auto get_optional_value_or ( optional<T> const& opt, typename optional<T>::reference_const_type def ) -> typename optional<T>::reference_const_type;

template<class T> inline auto get_optional_value_or ( optional<T> const& opt, typename optional<T>::reference_type def ) -> typename optional<T>::reference_type ;

template<class T> inline T const& get ( optional<T> const& opt ) ;

template<class T> inline T& get ( optional<T> & opt ) ;

template<class T> inline T const* get ( optional<T> const* opt ) ;

template<class T> inline T* get ( optional<T>* opt ) ;

template<class T> inline auto get_pointer ( optional<T> const& opt ) -> _see below_;

template<class T> inline auto get_pointer ( optional<T> & opt ) -> _see below_;

template<class T> inline void swap( optional<T>& x, optional<T>& y ) ;

template<class T> inline void swap( optional<T&>& x, optional<T&>& y ) ;

} // namespace boost

namespace std {

template <typename T>
struct hash<boost::optional<T> > ;

template <typename T>
struct hash<boost::optional<T&> > ;

} // namespace std
```

### Classes
- `boost::optional<T>`: Represents an optional value of type `T`.
- `boost::optional<T&>`: Represents an optional reference to a value of type `T`.
- `boost::in_place_init_t`: Tag type for in-place construction.
- `boost::in_place_init_if_t`: Tag type for conditional in-place construction.

### Functions
- `boost::make_optional`: Factory function to create `optional` objects.
- `boost::get_optional_value_or`: Retrieves the value of an `optional` or a default value.
- `boost::get`: Accesses the contained value of an `optional`.
- `boost::get_pointer`: Returns a pointer to the contained value.
- `boost::swap`: Swaps the contents of two `optional` objects.

### Operators
- Comparison operators (`==`, `!=`, `<`, `>`, `<=`, `>=`) for comparing `optional` objects with each other and with `none_t`.

### Namespace
- `boost`
- `std` (for `std::hash` specialization)
```

--------------------------------

### In-Place Initialization

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_values.html

Constructs objects directly within the optional using in-place initialization.

```cpp
// creates an std::mutex using its default constructor
optional<std::mutex> om {in_place_init};
assert (om);

// creates a unique_lock by calling unique_lock(*om, std::defer_lock)
optional<std::unique_lock<std::mutex>> ol {in_place_init, *om, std::defer_lock};
assert (ol);
assert (!ol->owns_lock());
```

--------------------------------

### Boost Optional Header Reference

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/optional/reference.html

Documentation for the <boost/none.hpp> header, which defines the tag used to represent an empty state in optional objects.

```APIDOC
## Header <boost/none.hpp>

### Description
Defines the `none_t` tag and `none` constant used to indicate that an optional object does not contain a value.

### Components
- **none_t** (class) - An empty, trivially copyable class with a disabled default constructor, used as a tag for selecting overloads in the `optional` interface.
- **none** (constant) - An inline constexpr instance of `none_t` used to indicate an optional object that does not contain a value during initialization, assignment, or relational operations.
```

--------------------------------

### Initialization Tags

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header_optional_in_place_init.html

Defines the `in_place_init_t` and `in_place_init_if_t` types and constants used for controlling overload resolution in the initialization of optional objects.

```APIDOC
## Initialization Tags

### Description

Classes `in_place_init_t` and `in_place_init_if_t` are empty classes designed to influence overload resolution during the initialization of optional objects. They are trivially copyable and have a disabled default constructor.

### Namespace

`boost`

### Types

- `in_place_init_t`: An empty class used as a tag for in-place initialization.
- `in_place_init_if_t`: An empty class used as a tag for conditional in-place initialization.

### Constants

- `in_place_init`: An instance of `in_place_init_t`.
- `in_place_init_if`: An instance of `in_place_init_if_t`.

### Usage Example (Conceptual)

```cpp
#include <boost/optional.hpp>

// Assuming boost::optional is configured to use these tags
boost::optional<MyClass> opt1(boost::in_place_init, arg1, arg2);
boost::optional<MyClass> opt2(boost::in_place_init_if, arg1, arg2);
```

### Copyright and License

Copyright © 2003-2007 Fernando Luis Cacciola Carballal
Copyright © 2014-2024 Andrzej Krzemieński
Distributed under the Boost Software License, Version 1.0.
```

--------------------------------

### Boost.Optional Header Synopsis

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/optional/reference/header__boost_optional_optional_hpp_.html

Contains the declarations for the optional class template, factory functions, and standard library hash specializations.

```cpp
// In Header: <boost/optional/optional.hpp>

namespace boost {

class in_place_init_t { /* see below */ } ; 
inline constexpr in_place_init_t in_place_init ( /* see below */ ) ;

class in_place_init_if_t { /*see below*/ } ; 
inline constexpr in_place_init_if_t in_place_init_if ( /*see below*/ ) ;

template <class T>
class optional ; 

template <class T>
class optional<T&> ; 

template<class T> inline bool operator == ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator != ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator <  ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator >  ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator <= ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator >= ( optional<T> const& x, optional<T> const& y ) ;

template<class T> inline bool operator == ( optional<T> const& x, none_t ) noexcept ;

template<class T> inline bool operator != ( optional<T> const& x, none_t ) noexcept ;

template<class T> inline optional<T> make_optional ( T const& v ) ;

template<class T> inline optional<std::decay_t<T>> make_optional ( T && v ) ;

template<class T> inline optional<T> make_optional ( bool condition, T const& v ) ;

template<class T> inline optional<std::decay_t<T>> make_optional ( bool condition, T && v ) ;

template<class T> inline auto get_optional_value_or ( optional<T> const& opt, typename optional<T>::reference_const_type def ) -> typename optional<T>::reference_const_type;

template<class T> inline auto get_optional_value_or ( optional<T> const& opt, typename optional<T>::reference_type def ) -> typename optional<T>::reference_type ;

template<class T> inline T const& get ( optional<T> const& opt ) ;

template<class T> inline T& get ( optional<T> & opt ) ;

template<class T> inline T const* get ( optional<T> const* opt ) ;

template<class T> inline T* get ( optional<T>* opt ) ;

template<class T> inline auto get_pointer ( optional<T> const& opt ) -> _see below_;

template<class T> inline auto get_pointer ( optional<T> & opt ) -> _see below_;

template<class T> inline void swap( optional<T>& x, optional<T>& y ) ;

template<class T> inline void swap( optional<T&>& x, optional<T&>& y ) ;

} // namespace boost

namespace std {

template <typename T>
struct hash<boost::optional<T> > ;

template <typename T>
struct hash<boost::optional<T&> > ;

} // namespace std
```

--------------------------------

### Inspect Optional Object State

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/iface.html

Shows how to check for the presence of a value and access it using pointer-like syntax.

```cpp
void inspect (optional<string> os)
{
  if (os) {               // contextual conversion to `bool`
    read_string(*os);     // `operator*` to access the stored value
    read_int(os->size()); // `operator->` as shortcut for accessing members
  }
}
```

--------------------------------

### In-place construction with emplace

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_values.html

Demonstrates creating or replacing the contained value in-place using various constructor arguments.

```cpp
T v;
optional<const T> opt;
opt.emplace(0);  // create in-place using ctor T(int)
opt.emplace();   // destroy previous and default-construct another T
opt.emplace(v);  // destroy and copy-construct in-place (no assignment called)
```

--------------------------------

### Store boost::optional in std::map

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/quick_overview/storage_in_containers.html

Demonstrates using boost::optional as a key in a map to track frequencies, including uninitialized states.

```cpp
std::map<boost::optional<int>, int> choices;

for (int i = 0; i < LIMIT; ++i) {
  boost::optional<int> choice = readChoice();
  ++choices[choice];
}
```

--------------------------------

### make_optional with Condition: Boost vs. Std

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/std_comp.html

Illustrates that Boost.Optional has a `make_optional` function that accepts a condition, a feature not in std::optional.

```cpp
make_optional(cond, v);
```

--------------------------------

### std::optional Initialization Ambiguity

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/convenience_conversions_and_deductions.html

Illustrates how std::optional's constructors can lead to ambiguity, especially when dealing with nested optionals or type aliases.

```cpp
Threshold th = /*வுகளை*/;
std::optional o = th;
assert (o);
```

```cpp
using Threshold = std::optional<int>;

Threshold th;
std::optional<Threshold> o = th;
assert(o);
```

```cpp
template <typename U>
optional(U const&);

template <typename U>
optional(optional<U> const&);
```

--------------------------------

### Synopsis for boost/optional/optional_io.hpp

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/io_header.html

Provides the declarations for stream insertion and extraction operators for optional types.

```cpp
#include <istream>
#include <ostream>
#include <boost/optional/optional.hpp>

namespace boost {

template <class CharType, class CharTrait, class T>
  std::basic_ostream<CharType, CharTrait>&
  operator<<(std::basic_ostream<CharType, CharTrait>& out, optional<T> const& v); 

  template <class CharType, class CharTrait>
  std::basic_ostream<CharType, CharTrait>&
  operator<<(std::basic_ostream<CharType, CharTrait>& out, none_t const&); 

template<class CharType, class CharTrait, class T>
  std::basic_istream<CharType, CharTrait>&
  operator>>(std::basic_istream<CharType, CharTrait>& in, optional<T>& v); 

} // namespace boost
```

--------------------------------

### Synopsis of boost/none.hpp

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/optional/reference.html

Defines the none_t tag class and the none constant for use with optional objects.

```cpp
namespace boost {

class none_t {/* see below */};

inline constexpr none_t none (/* see below */);

} // namespace boost
```

--------------------------------

### Workaround for GCC -Wmaybe-uninitialized Warning with Boost Optional

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/gotchas/false_positive_with__wmaybe_uninitialized.html

This is a workaround for the -Wmaybe-uninitialized warning that can occur with boost::optional on certain GCC versions. It initializes an optional containing no value in a way that suppresses the compiler warning.

```cpp
boost::optional<int> b = boost::make_optional(false, int());

```

--------------------------------

### Optimized record structure layout

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/advice/performance_considerations.html

A reordered structure layout to minimize padding and total size.

```cpp
struct Record
{
  bool _has_min;
  bool _has_max;
  int  _min;
  int  _max;
};
```

--------------------------------

### Swap optional<T> objects

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___free_functions.html

Demonstrates swapping two optional<T> objects, including cases where one or both are uninitialized.

```cpp
T x(12);
T y(21);
optional<T> def0 ;
optional<T> def1 ;
optional<T> optX(x);
optional<T> optY(y);

boost::swap(def0,def1); // no-op

boost::swap(def0,optX);
assert ( *def0 == x );
assert ( !optX );

boost::swap(def0,optX); // Get back to original values

boost::swap(optX,optY);
assert ( *optX == y );
assert ( *optY == x );
```

--------------------------------

### Construct bad_optional_access Exception

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html

Constructs an object of class bad_optional_access. The what() method returns an implementation-defined NTBS.

```cpp
bad_optional_access();
```

--------------------------------

### Comparisons with U and optional<U>: Std vs. Boost

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/std_comp.html

Shows that std::optional supports comparisons with other types and optional types, unlike Boost.Optional.

```cpp
optional<T>{} == U{};
optional<T>{} == optional<U>{}
```

--------------------------------

### bad_optional_access Exception

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_bad_optional_access_hpp_/detailed_semantics.html

Details about the `bad_optional_access` exception class used in Boost.Optional.

```APIDOC
## `bad_optional_access()`

### Description
Constructs an object of class `bad_optional_access`.

### Method
Constructor

### Endpoint
N/A

### Parameters
None

### Request Example
N/A

### Response
#### Success Response (N/A)
N/A

#### Response Example
N/A

### Postconditions
`what()` returns an implementation-defined NTBS (Null-Terminated Byte String).
```

--------------------------------

### Optional Reference Initialization Restrictions

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/design/optional_references.html

Demonstrates that optional references cannot be initialized from temporaries, unlike standard C++ references.

```cpp
const int& i = 1;            // legal
optional<const int&> oi = 1; // illegal
```

--------------------------------

### Construct Optional from boost::none

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_values.html

Construct an optional using boost::none to explicitly create an uninitialized optional. T's default constructor is not called.

```cpp
#include <boost/none.hpp>
optional<T> n(none) ;
assert ( !n ) ;
```

--------------------------------

### optional<T> Constructors

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___optional_values.html

API documentation for the various ways to construct an optional<T> object.

```APIDOC
## optional<T>::optional()

### Description
Default-Constructs an optional. The object is left uninitialized and T's default constructor is not called.

### Method
Constructor

### Request Example
optional<T> def;
assert(!def);
```

```APIDOC
## optional<T>::optional(none_t)

### Description
Constructs an optional in an uninitialized state using the none_t tag.

### Method
Constructor

### Request Example
#include <boost/none.hpp>
optional<T> n(none);
assert(!n);
```

```APIDOC
## optional<T>::optional(T const& v)

### Description
Directly-Constructs an optional by copying the provided value v.

### Method
Constructor

### Parameters
#### Request Body
- **v** (T const&) - Required - The value to copy into the optional.

### Request Example
T v;
optional<T> opt(v);
assert(*opt == v);
```

```APIDOC
## optional<T>::optional(T&& v)

### Description
Directly-Move-Constructs an optional from the provided value v.

### Method
Constructor

### Parameters
#### Request Body
- **v** (T&&) - Required - The value to move into the optional.

### Request Example
T v1;
optional<T> opt(std::move(v1));
```

```APIDOC
## optional<T>::optional(optional const& rhs)

### Description
Copy-Constructs an optional from another optional instance.

### Method
Constructor

### Parameters
#### Request Body
- **rhs** (optional const&) - Required - The optional instance to copy from.

### Request Example
optional<T> init(T(2));
optional<T> init2(init);
assert(init2 == init);
```

```APIDOC
## optional<T>::optional(optional&& rhs)

### Description
Move-constructs an optional from another optional instance.

### Method
Constructor

### Parameters
#### Request Body
- **rhs** (optional&&) - Required - The optional instance to move from.

### Request Example
optional<std::unique_ptr<T>> init(std::unique_ptr<T>(new T(2)));
optional<std::unique_ptr<T>> init2(std::move(init));
```

```APIDOC
## template<U> optional<T>::optional(optional<U> const& rhs)

### Description
Copy-Constructs an optional by converting the value from an optional of a different type U.

### Method
Constructor

### Parameters
#### Request Body
- **rhs** (optional<U> const&) - Required - The optional instance of type U to convert from.

### Request Example
optional<double> x(123.4);
assert(*x == 123.4);
```

--------------------------------

### make_optional Functions

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/detailed_semantics___free_functions.html

Functions to create optional objects with different initialization strategies.

```APIDOC
## make_optional Functions

### Description
Functions to create `optional` objects.

### `optional<T> make_optional( T const& v )`
* **Returns:** `optional<T>(v)` for the deduced type `T` of `v`.
* **Example:**
```cpp
template<class T> void foo ( optional<T> const& opt ) ;

foo ( make_optional(1+1) ) ; // Creates an optional<int>
```

### `optional<std::decay_t<T>> make_optional( T && v )`
* **Returns:** `optional<std::decay_t<T>>(std::move(v))` for the deduced type `T` of `v`.

### `optional<T> make_optional( bool condition, T const& v )`
* **Returns:** `optional<T>(condition, v)` for the deduced type `T` of `v`.
* **Example:**
```cpp
optional<double> calculate_foo()
{
  double val = compute_foo();
  return make_optional(is_not_nan_and_finite(val),val);
}

optional<double> v = calculate_foo();
if ( !v )
  error("foo wasn't computed");
```

### `optional<std::decay_t<T>> make_optional( bool condition, T && v )`
* **Returns:** `optional<std::decay_t<T>>(condition, std::move(v))` for the deduced type `T` of `v`.
```

--------------------------------

### Template Parameter Deduction: Boost vs. Std

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/std_comp.html

Shows that std::optional allows for template parameter deduction during initialization, unlike Boost.Optional.

```cpp
optional o = 1;
```

--------------------------------

### Define Initialization Tags in Boost

Source: https://www.boost.org/doc/libs/latest/libs/optional/doc/html/boost_optional/reference/header__boost_optional_optional_hpp_/header_optional_in_place_init.html

Defines the empty classes `in_place_init_t` and `in_place_init_if_t` and their corresponding constants. These are used to control overload resolution during the initialization of optional objects.

```cpp
namespace boost {

class in_place_init_t { /* see below */ } ;
const in_place_init_t in_place_init ( /* see below */ ) ;

class in_place_init_if_t { /*see below*/ } ;
const in_place_init_if_t in_place_init_if ( /*see below*/ ) ;

}
```