Corrade::Utility namespace

enum class Corrade::Utility::ConfigurationValueFlag: unsigned char

#include <Corrade/Utility/ConfigurationValue.h>

Configuration value conversion flag.

enum class Corrade::Utility::TweakableState: unsigned char

#include <Corrade/Utility/TweakableParser.h>

Tweakable state.

typedef Containers::EnumSet<ConfigurationValueFlag> Corrade::Utility::ConfigurationValueFlags

#include <Corrade/Utility/ConfigurationValue.h>

Configuration value conversion flags.

#include <Corrade/Utility/TypeTraits.h>

template<class T>

using Corrade::Utility::IsIterable = std::integral_constant<bool, implementation-specific>

Traits class for checking whether given type is iterable.

Equivalent to std::true_type if the class is has either begin() / end() members, is usable with free begin() / end() functions or has std::begin() / std::end() overloads. Otherwise equivalent to std::false_type.

Used together with IsStringLike by Debug to decide whether given type should be printed as a container of its contents or as a whole.

#include <Corrade/Utility/TypeTraits.h>

template<class T>

using Corrade::Utility::IsStringLike = std::integral_constant<bool, implementation-specific> new in 2019.10

Traits class for checking whether given type is string-like.

Equivalent to std::true_type if the class is has a c_str() or a substr() member or is a Containers::[Mutable]StringView / Containers::String. Otherwise equivalent to std::false_type. Useful for dispatching on the std::string or the C++17 std::string_view and std::filesystem::path types without having to include or forward-declare them.

Used together with IsIterable by Debug to decide whether given type should be printed as a container of its contents or as a whole.

void Corrade::Utility::copy(Containers::ArrayView<const void> src, Containers::ArrayView<void> dst) new in 2020.06

#include <Corrade/Utility/Algorithms.h>

Copy an array view to another.

Calls std::memcpy() on the contents. Expects that both arrays have the same size.

#include <Corrade/Utility/Algorithms.h>

template<class T>

void Corrade::Utility::copy(Containers::ArrayView<const T> src, Containers::ArrayView<T> dst) new in 2020.06

Copy an array view to another.

Casts views into a void type and delegates into copy(Containers::ArrayView<const void>, Containers::ArrayView<void>). Expects that T is a trivially copyable type.

#include <Corrade/Utility/Algorithms.h>

template<unsigned dimensions>

void Corrade::Utility::copy(const Containers::StridedArrayView<dimensions, const char>& src, const Containers::StridedArrayView<dimensions, char>& dst) new in 2020.06

Copy a strided array view to another.

Optimized to call std::memcpy() on largest contiguous sub-dimensions, looping over the non-contiguous dimensions (except when memcpy would be called for very small pieces of memory, in which case either a loop or a variant of Duff's device is used, depending on which is faster on given compiler). The function has specializations for 1D, 2D, 3D and 4D, higher dimensions recurse into these. Expects that both arrays have the same size.

void Corrade::Utility::copy(const Containers::StridedArrayView1D<const char>& src, const Containers::StridedArrayView1D<char>& dst) new in 2020.06

#include <Corrade/Utility/Algorithms.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Corrade::Utility::copy(const Containers::StridedArrayView2D<const char>& src, const Containers::StridedArrayView2D<char>& dst) new in 2020.06

#include <Corrade/Utility/Algorithms.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Corrade::Utility::copy(const Containers::StridedArrayView3D<const char>& src, const Containers::StridedArrayView3D<char>& dst) new in 2020.06

#include <Corrade/Utility/Algorithms.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

void Corrade::Utility::copy(const Containers::StridedArrayView4D<const char>& src, const Containers::StridedArrayView4D<char>& dst) new in 2020.06

#include <Corrade/Utility/Algorithms.h>

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Corrade/Utility/Algorithms.h>

template<unsigned dimensions, class T>

void Corrade::Utility::copy(const Containers::StridedArrayView<dimensions, const T>& src, const Containers::StridedArrayView<dimensions, T>& dst) new in 2020.06

Copy a strided array view to another.

Casts views into a char type of one dimension more (where the last dimension has a size of sizeof(T) and delegates into copy(const Containers::StridedArrayView<dimensions, const char>&, const Containers::StridedArrayView<dimensions, char>&). Expects that both arrays have the same size and T is a trivially copyable type.

#include <Corrade/Utility/Algorithms.h>

template<class To, class ToView = decltype(Implementation::arrayViewTypeFor(std::declval<To && >()))>

void Corrade::Utility::copy(std::initializer_list<typename ToView::Type> src, To&& dst) new in Git master

Copy an initializer list to a view.

Based on whether the dst is convertible to either Containers::ArrayView or Containers::StridedArrayView, calls either copy(Containers::ArrayView<const T>, Containers::ArrayView<T>) or copy(const Containers::StridedArrayView<dimensions, const T>& src, const Containers::StridedArrayView<dimensions, T>&). Works with any dst that's convertible to an one-dimensional Containers::StridedArrayView, expects that src has the same underlying type as dst, that they have both the same size and the dst is not const.

This overload can also be used for convenient filling of C arrays, which would otherwise have to be done element-by-element or using std::memcpy() as neither C nor C++ allows array assignment:

int a[3];

…

Utility::copy({1, 2, 3}, a);

#include <Corrade/Utility/Algorithms.h>

template<unsigned dimension, unsigned dimensions, class T>

void Corrade::Utility::flipInPlace(const Containers::StridedArrayView<dimensions, T>& view) new in Git master

Flip given dimension of a view in-place.

Swaps all items in dimension such that viewDimension[i] and viewDimension[dimensionSize - i - 1] exchange their contents for all i < dimensionSize/2. Expects that T is a trivially copyable type and the view is contiguous after dimension.

View flip not in place can be performed using a copy() to a view that has the desired dimension Containers::StridedArrayView::flipped(). In the following snippet, the first expression does the flip during a copy, while the second performs it in-place:

Containers::StridedArrayView2D<T> pixels = …;
Containers::StridedArrayView2D<T> destination = …;

/* Y-flip the pixels into a destination */
Utility::copy(pixels.flipped<0>(), destination);

/* Y-flip the pixels in-place */
Utility::flipInPlace<0>(pixels);

void Corrade::Utility::copyMasked(const Containers::StridedArrayView2D<const char>& src, Containers::BitArrayView srcMask, const Containers::StridedArrayView2D<char>& dst) new in Git master

#include <Corrade/Utility/BitAlgorithms.h>

Copy a masked array view to another.

For all bits that are set in srcMask takes an element from src and copies it to dst. Expects that src and srcMask have the same size, that count of bits set in srcMask is the same as dst size and that the second dimension of both src and dst has the same size and is contiguous.

#include <Corrade/Utility/BitAlgorithms.h>

template<class T>

void Corrade::Utility::copyMasked(const Containers::StridedArrayView1D<const T>& src, Containers::BitArrayView srcMask, const Containers::StridedArrayView1D<T>& dst) new in Git master

Copy a masked array view to another.

Casts views into a char type of one dimension more (where the last dimension has a size of sizeof(T) and delegates into copyMasked(const Containers::StridedArrayView2D<const char>&, Containers::BitArrayView, const Containers::StridedArrayView2D<char>&). Expects that T is a trivially copyable type.

Debug& Corrade::Utility::operator!(Implementation::DebugSourceLocation debug) new in 2020.06

#include <Corrade/Utility/Debug.h>

Prefix the output with source location.

Only on supported compilers, does nothing otherwise. See Source location for more information.

#include <Corrade/Utility/Debug.h>

template<class T>

Debug& Corrade::Utility::operator<<(Debug& debug, const T& value)

Operator for printing custom types to debug output.

Support for printing custom types (i.e. those not handled by std::iostream) can be added by implementing this function for given type.

The function should convert the type to one of supported types (such as the builtin types or std::string) and then call Debug::operator<<() with it. You can also use Debug::nospace and Debug::newline.

#include <Corrade/Utility/Debug.h>

template<class Iterable>

Debug& Corrade::Utility::operator<<(Debug& debug, const Iterable& value)

Operator for printing iterable types to debug output.

Prints the value as {a, b, …}. If the type contains a nested iterable type, the values are separated by newlines. Specifying Debug::Flag::Packed or using Debug::packed will print the values tightly-packed without commas and spaces in between.

#include <Corrade/Utility/DebugStl.h>

template<class T, class U>

Debug& Corrade::Utility::operator<<(Debug& debug, const std::pair<T, U>& value)

Print a std::pair to debug output.

Prints the value as (first, second). Unlike operator<<(Debug& debug, const Iterable& value), the output is not affected by Debug::Flag::Packed / Debug::packed.

Debug& Corrade::Utility::operator<<(Debug& debug, const std::string& value)

#include <Corrade/Utility/DebugStl.h>

Print a std::string to debug output.

For types that are only convertible to a std::string this overload is picked only if the type doesn't also provide a std::ostream operator<<() overload. In that case the value is printed directly to the stream instead, assuming it's a cheaper operation than conversion to a std::string. This is for example a case with std::filesystem::path.

#include <Corrade/Utility/DebugStl.h>

template<class T>

Debug& Corrade::Utility::operator<<(Debug& debug, const std::basic_string<T>& value)

Print a std::basic_string to debug output.

All other types than exactly std::string are printed as containers.

#include <Corrade/Utility/DebugStl.h>

template<class ... Args>

Debug& Corrade::Utility::operator<<(Debug& debug, const std::tuple<Args...>& value)

Print a std::tuple to debug output.

Prints the value as (first, second, third...). Unlike operator<<(Debug& debug, const Iterable& value), the output is not affected by Debug::Flag::Packed / Debug::packed.

Debug& Corrade::Utility::operator<<(Debug& debug, std::string_view value) new in Git master

#include <Corrade/Utility/DebugStlStringView.h>

Print a std::string_view to debug output.

#include <Corrade/Utility/DebugStlStringView.h>

template<class T>

Debug& Corrade::Utility::operator<<(Debug& debug, std::basic_string_view<T> value) new in Git master

Print a std::basic_string_view to debug output.

All other types than exactly std::string_view are printed as containers.

#include <Corrade/Utility/Format.h>

template<class ... Args>

Containers::String Corrade::Utility::format(const char* format, const Args&... args) new in 2019.10

Format a string.

Provides type-safe formatting of arbitrary types into a template string, similar in syntax to Python's format(). Example usage:

Containers::String s = Utility::format("{} version {}.{}.{}, {} MB",
    "vulkan.hpp", 1, 1, 76, 1.79);
// vulkan.hpp version 1.1.76, 1.79 MB

Templating language

Formatting placeholders are denoted by {}, which can have either implicit ordering (as shown above), or be numbered, such as {2}. Zero means first item from args, it's allowed to repeat the numbers. An implicit placeholder following a numbered one will get next position after. Example:

Containers::String s = Utility::format("<{0}><{1}>Good {}, {}!</{1}></{0}>",
    "p", "strong", "afternoon", "ma'am!");
// <p><strong>Good afternoon, ma'am!</strong></p>

Unlike in Python, it's allowed to both have more placeholders than arguments or more arguments than placeholders. Extraneous placeholders are copied to the output verbatim, extraneous arguments are simply ignored.

In order to write a literal curly brace to the output, simply double it:

Containers::String s = Utility::format("union {{ {} a; char data[{}]; }} caster;",
    "float", sizeof(float));
// union { float a; char data[4]; } caster;

Data type support

Advanced formatting options

Advanced formatting such as precision or presentation type is possible by putting extra options after a semicolon, following the optional placeholder number, such as {:x} to print an integer value in hexadecimal. In general, the syntax similar to the -style formatting, with the addition of {} and : used instead of % — for example, "%.2x" can be translated to "{:.2x}".

The full placeholder syntax is the following, again a subset of the Python format():

{[number][:[.precision][type]]}

The type is a single character specifying output conversion:

The precision field specifies a precision of the output. It's interpreted differently based on the data type:

Example of formating of CSS colors with correct width:

Containers::String s = Utility::format("path {{ fill: #{:.6x}; stroke: #{:.6x}; }}",
    0x33ff00, 0x00aa55);
// path { fill: #33ff00; stroke: #00aa55; }

Performance

This function always does exactly one allocation for the output array. See formatInto(std::string&, std::size_t, const char*, const Args&... args) for an ability to write into an existing std::string (with at most one reallocation) and formatInto(const Containers::MutableStringView&, const char*, const Args&... args) for a completely zero-allocation alternative. There is also formatInto(std::FILE*, const char*, const Args&... args) for writing to files or standard output.

Comparison to Debug

Debug class desired usage is for easy printing of complex nested types, containers, enum values or opaque types for logging and diagnostic purposes, with focus on convenience rather than speed or advanced formatting capabilities. The format() family of functions is intended for cases where it's required to have a complete control over the output, for example when serializing text files.

#include <Corrade/Utility/Format.h>

template<class ... Args>

std::size_t Corrade::Utility::formatInto(const Containers::MutableStringView& buffer, const char* format, const Args&... args)

Format a string into an existing buffer.

Writes formatted output to given buffer, expecting that it is large enough. The formatting is done completely without any allocation. Returns total amount of bytes written, does not write any terminating '\0' character. Example usage:

char shaderVersion[128]; // large enough
std::size_t size = Utility::formatInto(shaderVersion, "#version {}\n", 430);
addShaderSource({shaderVersion, size});

See format() for more information about usage and templating language.

#include <Corrade/Utility/Format.h>

template<class ... Args, std::size_t size>

std::size_t Corrade::Utility::formatInto(char(&buffer)[size], const char* format, const Args&... args)

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

#include <Corrade/Utility/Format.h>

template<class ... Args>

void Corrade::Utility::formatInto(std::FILE* file, const char* format, const Args&... args)

Format a string into a file.

Writes formatted output to file, which can be either an arbitrary file opened using std::fopen() or stdout / stderr. Does not allocate on its own (though the underlying file writing routines might), does not write any terminating '\0' character. Example usage:

Utility::formatInto(stdout, "Hello, {}!", "world");

See format() for more information about usage and templating language.

#include <Corrade/Utility/Format.h>

template<class ... Args>

void Corrade::Utility::print(const char* format, const Args&... args)

Print a string to the standard output.

Equivalent to calling formatInto(std::FILE*, const char*, const Args&... args) with stdout as a first parameter.

#include <Corrade/Utility/Format.h>

template<class ... Args>

void Corrade::Utility::printError(const char* format, const Args&... args)

Print a string to the standard error output.

Equivalent to calling formatInto(std::FILE*, const char*, const Args&... args) with stderr as a first parameter.

#include <Corrade/Utility/FormatStl.h>

template<class ... Args>

std::string Corrade::Utility::formatString(const char* format, const Args&... args)

Format a string.

Same as format(), but returning a std::string instead of Containers::String.

#include <Corrade/Utility/FormatStl.h>

template<class ... Args>

std::size_t Corrade::Utility::formatInto(std::string& string, std::size_t offset, const char* format, const Args&... args)

Format a string into an existing string.

Takes an existing string and writes the formatted content starting at offset. If the string is not large enough, does at most one reallocation (by calling std::string::resize()). Returns final written size (which might be less than the string size if inserting in the middle). Does not write any terminating '\0' character. Example usage:

std::vector<float> positions{-0.5f, -0.5f, 0.0f,
                              0.5f, -0.5f, 0.0f,
                              0.0f,  0.5f, 0.0f};
std::string out;
for(std::size_t i = 0; i < positions.size(); i += 3)
    Utility::formatInto(out, out.size(), "{}[{0}, {1}, {2}]",
        out.empty() ? "" : ", ",
        positions[i*3 + 0], positions[i*3 + 1], positions[i*3 + 2]);

// [-0.5, -0.5, 0], [0.5, -0.5, 0], [0.0, 0.5, 0.0]

See format() for more information about usage and templating language.

#include <Corrade/Utility/Math.h>

template<class T>

T Corrade::Utility::min(T value, T min) constexpr new in Git master

Minimum.

The main purpose of this function is to be used in places where having to #include <algorithm> to get std::min() would be an unnecessary overkill. It's primarily meant to be used on builtin scalar types, thus the arguments are taken by value and not by reference.

NaNs passed in the value parameter are propagated.

#include <Corrade/Utility/Math.h>

template<class T>

T Corrade::Utility::max(T value, T max) constexpr new in Git master

Maximum.

The main purpose of this function is to be used in places where having to #include <algorithm> to get std::max() would be an unnecessary overkill. It's primarily meant to be used on builtin scalar types, thus the arguments are taken by value and not by reference.

NaNs passed in the value parameter are propagated.

#include <Corrade/Utility/Math.h>

template<class T>

T Corrade::Utility::abs(T a) constexpr new in Git master

Absolute value.

The main purpose of this function is to be used in places where having to #include <cmath> to get std::abs() would be an unnecessary overkill. It's primarily meant to be used on builtin scalar types, thus the arguments are taken by value and not by reference.

#include <Corrade/Utility/Memory.h>

template<class T, std::size_t alignment = alignof(T)>

Containers::Array<T> Corrade::Utility::allocateAligned(std::size_t size) new in Git master

Allocate aligned memory and value-initialize it.

Compared to the classic C std::malloc() or C++ new that commonly aligns only to 2*sizeof(void*), this function returns "overaligned" allocations, which is mainly useful for efficient SIMD operations. Example usage:

Containers::Array<__m256> avxVectors =
    Utility::allocateAligned<__m256>(size);

The alignment is implicitly alignof(T), but can be overridden with the alignment template parameter. When specified explicitly, it is expected to be a power-of-two value, at most 256 bytes and the total byte size being a multiple of the alignment:

Containers::Array<Matrix4> avxMatrices =
    Utility::allocateAligned<Matrix4, 32>(size);

The returned pointer is always aligned to at least the desired value, but the alignment can be also higher. For example, allocating a 2 MB buffer may result in it being aligned to the whole memory page, or small alignment values could get rounded up to the default 2*sizeof(void*) alignment.

The function is implemented using posix_memalign() on UNIX systems and _aligned_malloc() on Windows. On other platforms (such as Emscripten), if requested alignment is higher than platform's default alignment, the allocation is done via a classic std::malloc() with an alignment - 1 padding and the returned pointer is then patched to satisfy the alignment. In all cases the returned Containers::Array has a custom deleter, which for non-trivial types calls destructors on all types, and then either std::free() or, in case of Windows, _aligned_free() is used to deallocate the memory.

Array initialization

Like with Containers::Array, the returned array is by default value-initialized, which means that trivial types are zero-initialized and the default constructor is called on other types. Different behavior can be achieved with the following tags, compared to Containers::Array the initialization is performed separately from the allocation itself with either a loop or a call to std::memset().

• allocateAligned(DefaultInitT, std::size_t) leaves trivial types uninitialized and calls the default constructor elsewhere. Because of the differing behavior for trivial types it's better to explicitly use either the ValueInit or NoInit variants instead.
• allocateAligned(ValueInitT, std::size_t) is equivalent to the default case, zero-initializing trivial types and calling the default constructor elsewhere. Useful when you want to make the choice appear explicit.
• allocateAligned(NoInitT, std::size_t) does not initialize anything. Useful for trivial types when you'll be overwriting the contents anyway, for non-trivial types this is the dangerous option and you need to call the constructor on all elements manually using placement new, std::uninitialized_copy() or similar — see the function docs for an example.

#include <Corrade/Utility/Memory.h>

template<class T, std::size_t alignment = alignof(T)>

Containers::Array<T> Corrade::Utility::allocateAligned(DefaultInitT, std::size_t size) new in Git master

Allocate aligned memory and default-initialize it.

Compared to allocateAligned(std::size_t), trivial types are not initialized and default constructor is called otherwise. Because of the differing behavior for trivial types it's better to explicitly use either the allocateAligned(ValueInitT, std::size_t) or the allocateAligned(NoInitT, std::size_t) variant instead.

Implemented via allocateAligned(NoInitT, std::size_t) with a loop calling the constructors on the returned allocation in case of non-trivial types.

#include <Corrade/Utility/Memory.h>

template<class T, std::size_t alignment = alignof(T)>

Containers::Array<T> Corrade::Utility::allocateAligned(ValueInitT, std::size_t size) new in Git master

Allocate aligned memory and value-initialize it.

Same as allocateAligned(std::size_t), just more explicit. Implemented via allocateAligned(NoInitT, std::size_t) with either a std::memset() or a loop calling the constructors on the returned allocation.

#include <Corrade/Utility/Memory.h>

template<class T, std::size_t alignment = alignof(T)>

Containers::Array<T> Corrade::Utility::allocateAligned(NoInitT, std::size_t size) new in Git master

Allocate aligned memory and leave it uninitialized.

Compared to allocateAligned(std::size_t), the memory is left in an unitialized state. For trivial types is equivalent to allocateAligned(DefaultInitT, std::size_t). For non-trivial types, destruction is always done using a custom deleter that explicitly calls the destructor on all elements — which means that for non-trivial types you're expected to construct all elements using placement new (or for example std::uninitialized_copy()) in order to avoid calling destructors on uninitialized memory:

struct Foo {
    explicit Foo(int) {}
    …
};

Containers::Array<Foo> data = Utility::allocateAligned<Foo>(NoInit, 5);

int index = 0;
for(Foo& f: data) new(&f) Foo{index++};

#include <Corrade/Utility/Move.h>

template<class T>

T&& Corrade::Utility::forward(typename std::remove_reference<T>::type& t) constexpr noexcept new in Git master

Forward an l-value.

Returns static_cast<T&&>(t). Equivalent to std::forward(), which is used to implement perfect forwarding, but without the #include <utility> dependency and guaranteed to be constexpr even in C++11.

#include <Corrade/Utility/Move.h>

template<class T>

T&& Corrade::Utility::forward(typename std::remove_reference<T>::type&& t) constexpr noexcept new in Git master

Forward an r-value.

Returns static_cast<T&&>(t). Equivalent to std::forward(), which is used to implement perfect forwarding, but without the #include <utility> dependency and guaranteed to be constexpr even in C++11.

#include <Corrade/Utility/Move.h>

template<class T>

std::remove_reference<T>::type&& Corrade::Utility::move(T&& t) constexpr noexcept new in Git master

Convert a value to an r-value.

Returns static_cast<typename std::remove_reference<T>::type&&>(t). Equivalent to std::move(), but without the #include <utility> dependency and guaranteed to be constexpr even in C++11.

#include <Corrade/Utility/Move.h>

template<class T>

void Corrade::Utility::swap(T& a, T& b) noexcept(…) new in Git master

Swap two values.

Swaps two values. Equivalent to std::swap(), but without the #include <utility> dependency, and without the internals delegating to std::move(), hurting debug performance. In order to keep supporting custom specializations, the usage pattern should be similar to the standard utility, i.e. with using Utility::swap:

MyClass& MyClass::operator=(MyClass&& other) noexcept {
    using Utility::swap;
    swap(other._member, _member);
    swap(other._another, _another);
    return *this;
}

#include <Corrade/Utility/Move.h>

template<std::size_t size, class T>

void Corrade::Utility::swap(T(&a)[size], T(&b)[size]) noexcept(…) new in Git master

Swap two arrays.

Does the same as swap(T&, T&), but for every array element.

Debug& Corrade::Utility::operator<<(Debug& debug, TweakableState value)

#include <Corrade/Utility/TweakableParser.h>

Debug output operator.

#include <Corrade/Utility/utilities.h>

template<class To, class From>

To Corrade::Utility::bitCast(const From& from)

Cast type to another of the same size.

Unlike reinterpret_cast this doesn't break strict-aliasing rules.