Full-fidelity C++ docs from code.

1
2
3
4
5
6
7
8
9/** Exit the program.

    The program will end immediately.

    @note Functions registered with `std::atexit` are not invoked.
*/
[[noreturn]]
void
terminate() noexcept;

1
2
3
4
5
6
7
8
9
10
11
12
13/** Return the distance between two points

    This function returns the distance between two points
    according to the Euclidean distance formula.

    @param x0 The x-coordinate of the first point
    @param y0 The y-coordinate of the first point
    @param x1 The x-coordinate of the second point
    @param y1 The y-coordinate of the second point
    @return The distance between the two points
*/
double
distance(double x0, double y0, double x1, double y1);

1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <vector>

/** Insert a value into a sorted vector, keeping it sorted.

    @pre `v` is sorted in ascending order.
    @post `v` is sorted in ascending order and contains `value`.

    @param v The sorted vector to insert into.
    @param value The value to insert.
    @return An iterator to the inserted element.
    @throws std::bad_alloc If the vector has to grow and cannot.
*/
std::vector<int>::iterator
insert_sorted(std::vector<int>& v, int value);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15#include <type_traits>

/** Computes the integer square root \f$\lfloor\sqrt{value}\rfloor\f$.

    This function calculates the square root of a given integral value
    using bit manipulation, in $O(\log value)$ time.

    @throws std::invalid_argument If the input value is negative.

    @tparam T The type of the input value. Must be an integral type.
    @param value The integral value to compute the square root of.
    @return The square root of the input value.
 */
template <typename T>
std::enable_if_t<std::is_integral_v<T>, T> sqrt(T value);

1
2
3
4
5
6
7
8
9
10
11
12
13struct abs_fn
{
    /** Compute the absolute value.

        @param x The input value.
        @return The absolute value of x.
    */
    double
    operator()(double x) const noexcept;
};

/** Return the absolute value of a number. */
constexpr abs_fn abs = {};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27#include <filesystem>

namespace detail {

/** The object that holds the lock.

    @implementationdefined
*/
class file_lock
{
public:
    ~file_lock();
};

} // namespace detail

/** Lock a file for exclusive access.

    The lock is held until the returned object is destroyed.

    @param path The path of the file to lock.
    @return An object that holds the lock.
    @throws std::system_error If the file cannot be locked.
*/
[[nodiscard]]
detail::file_lock
lock_file(std::filesystem::path const& path);