Corrade::Containers namespace

enum class Corrade::Containers::StringViewFlag: std::size_t new in Git master

#include <Corrade/Containers/StringView.h>

String view flag.

typedef ScopeGuard Corrade::Containers::ScopedExit

#include <Corrade/Containers/ScopedExit.h>

Scope guard.

#include <Corrade/Containers/StridedArrayView.h>

template<class T>

using Corrade::Containers::StridedArrayView1D = StridedArrayView<1, T> new in 2019.10

One-dimensional strided array view.

Convenience alternative to StridedArrayView<1, T>. See StridedArrayView for more information.

#include <Corrade/Containers/StridedArrayView.h>

template<class T>

using Corrade::Containers::StridedArrayView2D = StridedArrayView<2, T> new in 2019.10

Two-dimensional strided array view.

Convenience alternative to StridedArrayView<2, T>. See StridedArrayView for more information.

#include <Corrade/Containers/StridedArrayView.h>

template<class T>

using Corrade::Containers::StridedArrayView3D = StridedArrayView<3, T> new in 2019.10

Three-dimensional strided array view.

Convenience alternative to StridedArrayView<3, T>. See StridedArrayView for more information.

#include <Corrade/Containers/StridedArrayView.h>

template<class T>

using Corrade::Containers::StridedArrayView4D = StridedArrayView<4, T> new in 2019.10

Four-dimensional strided array view.

Convenience alternative to StridedArrayView<4, T>. See StridedArrayView for more information.

typedef EnumSet<StringViewFlag> Corrade::Containers::StringViewFlags new in Git master

#include <Corrade/Containers/StringView.h>

String view flags.

typedef BasicStringView<const char> Corrade::Containers::StringView new in Git master

#include <Corrade/Containers/StringView.h>

String view.

Immutable, use MutableStringView for mutable access.

typedef BasicStringView<char> Corrade::Containers::MutableStringView new in Git master

#include <Corrade/Containers/StringView.h>

Mutable string view.

#include <Corrade/Containers/Array.h>

template<class T>

Array<T> Corrade::Containers::array(std::initializer_list<T> list) new in 2020.06

Construct a list-initialized array.

Convenience shortcut to the Array::Array(InPlaceInitT, std::initializer_list<T>) constructor. See its documentation for a design rationale.

#include <Corrade/Containers/Array.h>

template<class T, class D>

ArrayView<T> Corrade::Containers::arrayView(Array<T, D>& array)

Make view on Array.

Convenience alternative to converting to an ArrayView explicitly. The following two lines are equivalent:

Containers::Array<std::uint32_t> data;

Containers::ArrayView<std::uint32_t> a{data};
auto b = Containers::arrayView(data);

#include <Corrade/Containers/Array.h>

template<class T, class D>

ArrayView<const T> Corrade::Containers::arrayView(const Array<T, D>& array)

Make view on const Array.

Convenience alternative to converting to an ArrayView explicitly. The following two lines are equivalent:

const Containers::Array<std::uint32_t> data;

Containers::ArrayView<const std::uint32_t> a{data};
auto b = Containers::arrayView(data);

#include <Corrade/Containers/Array.h>

template<class U, class T, class D>

ArrayView<U> Corrade::Containers::arrayCast(Array<T, D>& array)

Reinterpret-cast an array.

See arrayCast(ArrayView<T>) for more information.

#include <Corrade/Containers/Array.h>

template<class U, class T, class D>

ArrayView<const U> Corrade::Containers::arrayCast(const Array<T, D>& array)

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

#include <Corrade/Containers/Array.h>

template<class T>

std::size_t Corrade::Containers::arraySize(const Array<T>& view)

Array size.

See arraySize(ArrayView<T>) for more information.

#include <Corrade/Containers/ArrayView.h>

template<class T>

ArrayView<T> Corrade::Containers::arrayView(T* data, std::size_t size) constexpr

Make a view on an array of specific length.

Convenience alternative to ArrayView::ArrayView(T*, std::size_t). The following two lines are equivalent:

std::uint32_t* data;

Containers::ArrayView<std::uint32_t> a{data, 5};
auto b = Containers::arrayView(data, 5);

#include <Corrade/Containers/ArrayView.h>

template<std::size_t size, class T>

ArrayView<T> Corrade::Containers::arrayView(T(&data)[size]) constexpr

Make a view on fixed-size array.

Convenience alternative to ArrayView::ArrayView(U(&)[size]). The following two lines are equivalent:

std::uint32_t data[15];

Containers::ArrayView<std::uint32_t> a{data};
auto b = Containers::arrayView(data);

#include <Corrade/Containers/ArrayView.h>

template<class T>

ArrayView<const T> Corrade::Containers::arrayView(std::initializer_list<T> list) new in 2020.06

Make a view on an initializer list.

Not present as a constructor in order to avoid accidental dangling references with r-value initializer lists. See class documentation for more information.

#include <Corrade/Containers/ArrayView.h>

template<std::size_t size, class T>

ArrayView<T> Corrade::Containers::arrayView(StaticArrayView<size, T> view) constexpr

Make a view on StaticArrayView.

Convenience alternative to ArrayView::ArrayView(StaticArrayView<size, U>). The following two lines are equivalent:

Containers::StaticArrayView<15, std::uint32_t> data;

Containers::ArrayView<std::uint32_t> a{data};
auto b = Containers::arrayView(data);

#include <Corrade/Containers/ArrayView.h>

template<class T>

ArrayView<T> Corrade::Containers::arrayView(ArrayView<T> view) constexpr

Make a view on a view.

Equivalent to the implicit ArrayView copy constructor — it shouldn't be an error to call arrayView() on itself.

#include <Corrade/Containers/ArrayView.h>

template<class T, class U = decltype(Implementation::ErasedArrayViewConverter<typename std::remove_reference<T && >::type>::from(std::declval<T && >()))>

U Corrade::Containers::arrayView(T&& other) constexpr

Make a view on an external type / from an external representation.

#include <Corrade/Containers/ArrayView.h>

template<class U, class T>

ArrayView<U> Corrade::Containers::arrayCast(ArrayView<T> view)

Reinterpret-cast an array view.

Size of the new array is calculated as view.size()*sizeof(T)/sizeof(U). Expects that both types are standard layout and the total byte size doesn't change. Example usage:

std::int32_t data[15];
auto a = Containers::arrayView(data); // a.size() == 15
auto b = Containers::arrayCast<char>(a); // b.size() == 60

#include <Corrade/Containers/ArrayView.h>

template<class U>

ArrayView<U> Corrade::Containers::arrayCast(ArrayView<const void> view) new in 2020.06

Reinterpret-cast a void array view.

Size of the new array is calculated as view.size()/sizeof(U). Expects that the target type is standard layout and the total byte size doesn't change.

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

#include <Corrade/Containers/ArrayView.h>

template<class T>

std::size_t Corrade::Containers::arraySize(ArrayView<T> view) constexpr

Array view size.

Alias to ArrayView::size(), useful as a shorthand in cases like this:

std::int32_t a[5];

std::size_t size = Containers::arraySize(a); // size == 5

#include <Corrade/Containers/ArrayView.h>

template<std::size_t size_, class T>

std::size_t Corrade::Containers::arraySize(StaticArrayView<size_, T>) constexpr

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

#include <Corrade/Containers/ArrayView.h>

template<std::size_t size_, class T>

std::size_t Corrade::Containers::arraySize(T(&)[size_]) constexpr

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

#include <Corrade/Containers/ArrayView.h>

template<std::size_t size, class T>

StaticArrayView<size, T> Corrade::Containers::staticArrayView(T* data) constexpr

Make a static view on an array.

Convenience alternative to StaticArrayView::StaticArrayView(T*). The following two lines are equivalent:

std::uint32_t* data;

Containers::StaticArrayView<5, std::uint32_t> a{data};
auto b = Containers::staticArrayView<5>(data);

#include <Corrade/Containers/ArrayView.h>

template<std::size_t size, class T>

StaticArrayView<size, T> Corrade::Containers::staticArrayView(T(&data)[size]) constexpr

Make a static view on a fixed-size array.

Convenience alternative to StaticArrayView::StaticArrayView(U(&)[size_]). The following two lines are equivalent:

std::uint32_t data[15];

Containers::StaticArrayView<15, std::uint32_t> a{data};
auto b = Containers::staticArrayView(data);

#include <Corrade/Containers/ArrayView.h>

template<std::size_t size, class T>

StaticArrayView<size, T> Corrade::Containers::staticArrayView(StaticArrayView<size, T> view) constexpr

Make a static view on a view.

Equivalent to the implicit StaticArrayView copy constructor — it shouldn't be an error to call staticArrayView() on itself.

#include <Corrade/Containers/ArrayView.h>

template<class T, class U = decltype(Implementation::ErasedStaticArrayViewConverter<typename std::remove_reference<T && >::type>::from(std::declval<T && >()))>

U Corrade::Containers::staticArrayView(T&& other) constexpr

Make a static view on an external type / from an external representation.

#include <Corrade/Containers/ArrayView.h>

template<class U, std::size_t size, class T>

StaticArrayView<size*sizeof(T)/sizeof(U), U> Corrade::Containers::arrayCast(StaticArrayView<size, T> view)

Reinterpret-cast a static array view.

Size of the new array is calculated as view.size()*sizeof(T)/sizeof(U). Expects that both types are standard layout and the total byte size doesn't change. Example usage:

std::int32_t data[15];
auto a = Containers::staticArrayView(data); // a.size() == 15
Containers::StaticArrayView<60, char> b = Containers::arrayCast<char>(a);

#include <Corrade/Containers/ArrayView.h>

template<class U, std::size_t size, class T>

StaticArrayView<size*sizeof(T)/sizeof(U), U> Corrade::Containers::arrayCast(T(&data)[size])

Reinterpret-cast a statically sized array.

Calls arrayCast(StaticArrayView<size, T>) with the argument converted to StaticArrayView of the same type and size. Example usage:

std::int32_t data[15];
auto a = Containers::arrayCast<char>(data); // a.size() == 60

#include <Corrade/Containers/EnumSet.h>

template<class T, class = typename std::enable_if<std::is_enum<T>::value>::type>

std::underlying_type<T>::type Corrade::Containers::enumCastUnderlyingType(T value) constexpr new in 2020.06

Cast an enum to its underlying type.

#include <Corrade/Containers/EnumSet.h>

template<class T, typename std::underlying_type<T>::type fullValue>

std::underlying_type<T>::type Corrade::Containers::enumCastUnderlyingType(EnumSet<T, fullValue> value) constexpr new in 2020.06

Cast an enum set to its underlying type.

#include <Corrade/Containers/EnumSet.hpp>

template<class T, typename std::underlying_type<T>::type fullValue>

Utility::Debug& Corrade::Containers::enumSetDebugOutput(Utility::Debug& debug, EnumSet<T, fullValue> value, const char* empty, std::initializer_list<T> enums)

Print enum set to debug output.

Assuming underlying enum type has already implemented operator<< for Utility::Debug, this function is able to print value of given enum set. Example definition:

enum class Feature: unsigned int {
    Fast = 1 << 0,
    Cheap = 1 << 1,
    Tested = 1 << 2,
    Popular = 1 << 3
};

// already defined to print values as e.g. Feature::Fast and Features(0xabcd)
// for unknown values
Utility::Debug& operator<<(Utility::Debug&, Feature);

typedef Containers::EnumSet<Feature> Features;
CORRADE_ENUMSET_OPERATORS(Features)

Utility::Debug& operator<<(Utility::Debug& debug, Features value) {
    return Containers::enumSetDebugOutput(debug, value, "Features{}", {
        Feature::Fast,
        Feature::Cheap,
        Feature::Tested,
        Feature::Popular});
}

The usage would be then straightforward:

// prints Feature::Fast|Feature::Cheap
Utility::Debug{} << (Feature::Fast|Feature::Cheap);

// prints Feature::Popular|Feature(0xdead)
Utility::Debug{} << (Feature::Popular|Feature(0xdead));

// prints Features{}
Utility::Debug{} << Features{};

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator, class... Args>

T& Corrade::Containers::arrayAppend(Array<T>& array, InPlaceInitT, Args && ... args) new in 2020.06

In-place append an item to an array.

Similar to arrayAppend(Array<T>&, const T&) except that the new element is constructed using placement-new with provided args.

#include <Corrade/Containers/Optional.h>

template<class T>

Optional<typename std::decay<T>::type> Corrade::Containers::optional(T&& value)

Make an optional.

Convenience alternative to Optional::Optional(const T&) or Optional::Optional(T&&). The following two lines are equivalent:

std::string value;

auto a = Containers::Optional<std::string>{value};
auto b = Containers::optional(value);

#include <Corrade/Containers/Optional.h>

template<class T, class ... Args>

Optional<T> Corrade::Containers::optional(Args && ... args)

Make an optional.

Convenience alternative to Optional::Optional(InPlaceInitT, Args&&... args). The following two lines are equivalent:

auto a = Containers::Optional<std::string>{Containers::InPlaceInit, 'a', 'b'};
auto b = Containers::optional<std::string>('a', 'b');

#include <Corrade/Containers/Optional.h>

template<class T>

auto Corrade::Containers::optional(T&& other)

Make an optional from external representation.

#include <Corrade/Containers/Pointer.h>

template<class T>

Pointer<T> Corrade::Containers::pointer(T* pointer)

Make a unique pointer.

Convenience alternative to Pointer::Pointer(T*). The following two lines are equivalent:

std::string* ptr;

auto a = Containers::Pointer<std::string>{ptr};
auto b = Containers::pointer(ptr);

#include <Corrade/Containers/Pointer.h>

template<class T>

auto Corrade::Containers::pointer(T&& other)

Make a unique pointer from external representation.

#include <Corrade/Containers/Pointer.h>

template<class U, class T>

Pointer<U> Corrade::Containers::pointerCast(Pointer<T>&& pointer)

Downcast a pointer.

While upcasting (derived to base) is handled implicitly with Pointer::Pointer(Pointer<U>&&), downcasting needs to be done explicitly. Performs static_cast<U>(), calling Pointer::release() on pointer. You have to ensure the pointer is actually of type U, as only the inheritance relation between T and U is checked at compile time, not the actual type stored in pointer.

Casting with dynamic_cast<U>() is not supported, as it would lead to a destructive behavior in case the instance is not of type U. The standard library provides std::dynamic_pointer_cast() and friends for this case, but they return a std::shared_ptr in order to behave non-destructively.

#include <Corrade/Containers/Pointer.h>

template<class T, class ... Args>

Pointer<T> Corrade::Containers::pointer(Args && ... args)

Make a unique pointer.

Convenience alternative to Pointer::Pointer(InPlaceInitT, Args&&... args), similar to std::make_unique() from C++14. The following two lines are equivalent:

auto a = Containers::Pointer<std::string>{Containers::InPlaceInit, 'a', 'b'};
auto b = Containers::pointer<std::string>('a', 'b');

#include <Corrade/Containers/StaticArray.h>

template<std::size_t size, class T>

ArrayView<T> Corrade::Containers::arrayView(StaticArray<size, T>& array) constexpr

Make view on StaticArray.

Convenience alternative to converting to an ArrayView explicitly. The following two lines are equivalent:

Containers::StaticArray<5, std::uint32_t> data;

Containers::ArrayView<std::uint32_t> a{data};
auto b = Containers::arrayView(data);

#include <Corrade/Containers/StaticArray.h>

template<std::size_t size, class T>

ArrayView<const T> Corrade::Containers::arrayView(const StaticArray<size, T>& array) constexpr

Make view on const StaticArray.

Convenience alternative to converting to an ArrayView explicitly. The following two lines are equivalent:

const Containers::StaticArray<5, std::uint32_t> data;

Containers::ArrayView<const std::uint32_t> a{data};
auto b = Containers::arrayView(data);

#include <Corrade/Containers/StaticArray.h>

template<std::size_t size, class T>

StaticArrayView<size, T> Corrade::Containers::staticArrayView(StaticArray<size, T>& array) constexpr

Make static view on StaticArray.

Convenience alternative to converting to an StaticArrayView explicitly. The following two lines are equivalent:

Containers::StaticArray<5, std::uint32_t> data;

Containers::StaticArrayView<5, std::uint32_t> a{data};
auto b = Containers::staticArrayView(data);

#include <Corrade/Containers/StaticArray.h>

template<std::size_t size, class T>

StaticArrayView<size, const T> Corrade::Containers::staticArrayView(const StaticArray<size, T>& array) constexpr

Make static view on const StaticArray.

Convenience alternative to converting to an StaticArrayView explicitly. The following two lines are equivalent:

const Containers::StaticArray<5, std::uint32_t> data;

Containers::StaticArrayView<5, const std::uint32_t> a{data};
auto b = Containers::staticArrayView(data);

#include <Corrade/Containers/StaticArray.h>

template<class U, std::size_t size, class T>

StaticArrayView<size*sizeof(T)/sizeof(U), U> Corrade::Containers::arrayCast(StaticArray<size, T>& array)

Reinterpret-cast a static array.

See arrayCast(StaticArrayView<size, T>) for more information.

#include <Corrade/Containers/StaticArray.h>

template<class U, std::size_t size, class T>

StaticArrayView<size*sizeof(T)/sizeof(U), const U> Corrade::Containers::arrayCast(const StaticArray<size, T>& array)

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

#include <Corrade/Containers/StaticArray.h>

template<std::size_t size_, class T>

std::size_t Corrade::Containers::arraySize(const StaticArray<size_, T>&) constexpr

Static array size.

See arraySize(ArrayView<T>) for more information.

#include <Corrade/Containers/StridedArrayView.h>

template<class T>

StridedArrayView1D<T> Corrade::Containers::stridedArrayView(ArrayView<typename StridedArrayView1D<T>::ErasedType> data, T* member, std::size_t size, std::ptrdiff_t stride) constexpr new in 2020.06

Make an one-dimensional strided view.

Convenience alternative to StridedArrayView::StridedArrayView(ArrayView<ErasedType>, T*, const Size&, const Stride&). The following two lines are equivalent:

Containers::ArrayView<Position> data;

Containers::StridedArrayView1D<float> a{data, &data[0].x, 9, sizeof(Position)};
auto b = Containers::stridedArrayView(data, &data[0].x, 9, sizeof(Position));

#include <Corrade/Containers/StridedArrayView.h>

template<std::size_t size, class T>

StridedArrayView1D<T> Corrade::Containers::stridedArrayView(T(&data)[size]) constexpr new in 2019.10

Make a strided view on a fixed-size array.

Convenience alternative to StridedArrayView::StridedArrayView(U(&)[size]). The following two lines are equivalent:

std::uint32_t data[15];

Containers::StridedArrayView1D<std::uint32_t> a{data};
auto b = Containers::stridedArrayView(data);

#include <Corrade/Containers/StridedArrayView.h>

template<class T>

StridedArrayView1D<const T> Corrade::Containers::stridedArrayView(std::initializer_list<T> list) new in 2020.06

Make a strided view on an initializer list.

Not present as a constructor in order to avoid accidental dangling references with r-value initializer lists. See ArrayView documentation for more information.

#include <Corrade/Containers/StridedArrayView.h>

template<class T>

StridedArrayView1D<T> Corrade::Containers::stridedArrayView(ArrayView<T> view) constexpr new in 2019.10

Make a strided view on ArrayView.

Convenience alternative to StridedArrayView::StridedArrayView(ArrayView<U>). The following two lines are equivalent:

Containers::ArrayView<std::uint32_t> data;

Containers::StridedArrayView1D<std::uint32_t> a{data};
auto b = Containers::stridedArrayView(data);

#include <Corrade/Containers/StridedArrayView.h>

template<std::size_t size, class T>

StridedArrayView1D<T> Corrade::Containers::stridedArrayView(StaticArrayView<size, T> view) constexpr new in 2019.10

Make a strided view on StaticArrayView.

Convenience alternative to StridedArrayView::StridedArrayView(StaticArrayView<size, U>). The following two lines are equivalent:

Containers::StaticArrayView<15, std::uint32_t> data;

Containers::StridedArrayView1D<std::uint32_t> a{data};
auto b = Containers::stridedArrayView(data);

#include <Corrade/Containers/StridedArrayView.h>

template<unsigned dimensions, class T>

StridedArrayView<dimensions, T> Corrade::Containers::stridedArrayView(StridedArrayView<dimensions, T> view) constexpr new in 2019.10

Make a view on a view.

Equivalent to the implicit StridedArrayView copy constructor — it shouldn't be an error to call stridedArrayView() on itself.

#include <Corrade/Containers/StridedArrayView.h>

template<class T, class U = decltype(stridedArrayView(Implementation::ErasedArrayViewConverter<typename std::remove_reference<T && >::type>::from(std::declval<T && >())))>

U Corrade::Containers::stridedArrayView(T&& other) constexpr new in 2019.10

Make a strided view on an external type / from an external representation.

#include <Corrade/Containers/StridedArrayView.h>

template<class U, unsigned dimensions, class T>

StridedArrayView<dimensions, U> Corrade::Containers::arrayCast(const StridedArrayView<dimensions, T>& view)

Reinterpret-cast a strided array view.

Size of the new array is the same as original. Expects that both types are standard layout and sizeof(U) is not larger than any stride() of the original array. Works with negative and zero strides as well, however note that no type compatibility checks can be done for zero strides, so be extra careful in that case. Example usage:

struct Pixel {
    std::uint8_t r, g, b, a;
};

Pixel pixels[]{{0x33, 0xff, 0x99, 0x66}, {0x11, 0xab, 0x33, 0xff}};

auto red = Containers::StridedArrayView1D<std::uint8_t>{pixels, &pixels[0].r, 2, 4};
auto rgba = Containers::arrayCast<Pixel>(red);

#include <Corrade/Containers/StridedArrayView.h>

template<class U, unsigned dimensions>

StridedArrayView<dimensions, U> Corrade::Containers::arrayCast(const StridedArrayView<dimensions, const void>& view) new in 2020.06

Reinterpret-cast a void strided array view.

Size of the new array is the same as original. Expects that the target type is standard layout and sizeof(U) is not larger than any stride() of the original array. Works with negative and zero strides as well, however note that no type compatibility checks can be done for zero strides, so be extra careful in that case.

#include <Corrade/Containers/StridedArrayView.h>

template<class U, unsigned dimensions>

StridedArrayView<dimensions, U> Corrade::Containers::arrayCast(const StridedArrayView<dimensions, void>& view) new in 2020.06

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

#include <Corrade/Containers/StridedArrayView.h>

template<unsigned newDimensions, class U, unsigned dimensions, class T>

StridedArrayView<newDimensions, U> Corrade::Containers::arrayCast(const StridedArrayView<dimensions, T>& view) new in 2019.10

Reinterpret-cast and inflate or flatten a strided array view.

If newDimensions > dimensions, inflates the last dimension into the new type U, its element count being ratio of T and U sizes. The newDimensions template parameter is expected to always be one more than dimensions. This operation can be used for example to peek into individual channels pixel data:

struct Rgb {
    std::uint8_t r, g, b;
};

Containers::ArrayView<Rgb> pixels;

Containers::StridedArrayView2D<Rgb> view{pixels, {128, 128}};
Containers::StridedArrayView3D<std::uint8_t> rgb =
    Containers::arrayCast<3, std::uint8_t>(view);

If newDimensions < dimensions, flattens the last dimension into a contiguous new type U, expecting the last dimension to be contiguous and its stride equal to size of U. The newDimensions template parameter is expected to always be one less than dimensions.

Lastly, if newDimensions == dimensions, the last dimension is reinterpreted as U, expecting it to be contiguous and its total byte size being divisible by the size of U. The resulting last dimension has a size that's a ratio of T and U sizes and stride equivalent to U, being again contiguous.

Expects that both types are standard layout and sizeof(U) is not larger than any stride() of the original array. Works with negative and zero strides as well, however note that no type compatibility checks can be done for zero strides, so be extra careful in that case.

#include <Corrade/Containers/StridedArrayView.h>

template<unsigned newDimensions, class U, class T>

StridedArrayView<newDimensions, U> Corrade::Containers::arrayCast(const ArrayView<T>& view) new in 2020.06

Reinterpret-cast and inflate an array view.

Converts view to a StridedArrayView1D and calls the above function.

#include <Corrade/Containers/StridedArrayView.h>

template<unsigned newDimensions, class U, unsigned dimensions>

StridedArrayView<newDimensions, U> Corrade::Containers::arrayCast(const StridedArrayView<dimensions, const void>& view, std::size_t lastDimensionSize) new in 2020.06

Reinterpret-cast and inflate a void strided array view.

Inflates the last dimension into the new type U, its element count being lastDimensionSize. The newDimensions template parameter is expected to always be one more than dimensions. For flattening the view (inverse of this operation) you need to cast to a concrete type first.

Expects that the target type is standard layout and sizeof(U) is not larger than any stride() of the original array. Works with negative and zero strides as well, however note that no type compatibility checks can be done for zero strides, so be extra careful in that case.

#include <Corrade/Containers/StridedArrayView.h>

template<unsigned newDimensions, class U, unsigned dimensions>

StridedArrayView<newDimensions, U> Corrade::Containers::arrayCast(const StridedArrayView<dimensions, void>& view, std::size_t lastDimensionSize) new in 2020.06

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

bool Corrade::Containers::operator==(StringView a, StringView b) new in Git master

#include <Corrade/Containers/StringView.h>

String view equality comparison.

bool Corrade::Containers::operator!=(StringView a, StringView b) new in Git master

#include <Corrade/Containers/StringView.h>

String view non-equality comparison.

bool Corrade::Containers::operator<(StringView a, StringView b) new in Git master

#include <Corrade/Containers/StringView.h>

String view less-than comparison.

bool Corrade::Containers::operator<=(StringView a, StringView b) new in Git master

#include <Corrade/Containers/StringView.h>

String view less-than-or-equal comparison.

bool Corrade::Containers::operator>=(StringView a, StringView b) new in Git master

#include <Corrade/Containers/StringView.h>

String view greater-than-or-equal comparison.

bool Corrade::Containers::operator>(StringView a, StringView b) new in Git master

#include <Corrade/Containers/StringView.h>

String view greater-than comparison.

#include <Corrade/Containers/GrowableArray.h>

template<class U, class T>

Array<U> Corrade::Containers::arrayAllocatorCast(Array<T>&& array) new in 2020.06

Reinterpret-cast a growable array.

If the array is growable using ArrayMallocAllocator (which is aliased to ArrayAllocator for all trivially-copyable types), the deleter is a simple call to a typeless std::free(). This makes it possible to change the array type without having to use a different deleter, losing the growable property in the process. Example usage:

Containers::Array<char> data;
Containers::Array<float> floats =
    Containers::arrayAllocatorCast<float>(std::move(data));
arrayAppend(floats, 37.0f);

Equivalently to to arrayCast(), the size of the new array is calculated as view.size()*sizeof(T)/sizeof(U). Expects that both types are trivially copyable and standard layout and the total byte size doesn't change.

#include <Corrade/Containers/GrowableArray.h>

template<class U, template<class> class Allocator, class T>

Array<U> Corrade::Containers::arrayAllocatorCast(Array<T>&& array) new in 2020.06

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

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

bool Corrade::Containers::arrayIsGrowable(Array<T>& array) new in 2020.06

Whether the array is growable.

Returns true if the array is growable and using given Allocator, false otherwise. Note that even non-growable arrays are usable with the arrayAppend(), arrayReserve(), ... family of utilities — these will reallocate the array using provided allocator if needed.

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

std::size_t Corrade::Containers::arrayCapacity(Array<T>& array) new in 2020.06

Array capacity.

For a growable array returns its capacity, for a non-growable array returns Array::size().

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

std::size_t Corrade::Containers::arrayReserve(Array<T>& array, std::size_t capacity) new in 2020.06

Reserve given capacity in an array.

If array capacity is already large enough, the function returns the current capacity. Otherwise the memory is reallocated to desired capacity, with the Array::size() staying the same, and capacity returned back. Note that in case the array is non-growable of sufficient size, it's kept as such, without being reallocated to a growable version.

Complexity is at most in the size of the original container, if the capacity is already large enough or if the reallocation can be done in-place.

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

void Corrade::Containers::arrayResize(Array<T>& array, DefaultInitT, std::size_t size) new in 2020.06

Resize an array to given size, default-initializing new elements.

If the array is growable and capacity is large enough, calls a destructor on elements that get cut off the end (if any, and if T is not trivially destructible, in which case nothing is done) and returns. Otherwise, the memory is reallocated to desired size. After that, new elements at the end of the array are default-initialized using placement-new (and nothing done for trivial types). Note that in case the array is non-growable of exactly the requested size, it's kept as such, without being reallocated to a growable version.

Complexity is at most in the size of the new container, if current container size is already exactly of given size.

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

void Corrade::Containers::arrayResize(Array<T>& array, ValueInitT, std::size_t size) new in 2020.06

Resize an array to given size, value-initializing new elements.

Similar to arrayResize(Array<T>&, DefaultInitT, std::size_t) except that the new elements at the end are not default-initialized, but value-initialized (i.e., trivial types zero-initialized and default constructor called otherwise).

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

void Corrade::Containers::arrayResize(Array<T>& array, std::size_t size) new in 2020.06

Resize an array to given size, value-initializing new elements.

Alias to arrayResize(Array<T>&, ValueInitT, std::size_t).

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

void Corrade::Containers::arrayResize(Array<T>& array, NoInitT, std::size_t size) new in 2020.06

Resize an array to given size, keeping new elements uninitialized.

Similar to arrayResize(Array<T>&, DefaultInitT, std::size_t) except that the new elements at the end are not default-initialized, but left in an uninitialized state instead.

#include <Corrade/Containers/GrowableArray.h>

template<class T, class... Args>

void Corrade::Containers::arrayResize(Array<T>& array, DirectInitT, std::size_t size, Args && ... args) new in 2020.06

Resize an array to given size, constructing new elements using provided arguments.

Similar to arrayResize(Array<T>&, DefaultInitT, std::size_t) except that the new elements at the end are constructed using placement-new with provided args.

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator, class... Args>

void Corrade::Containers::arrayResize(Array<T>& array, DirectInitT, std::size_t size, Args && ... args) new in 2020.06

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

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

T& Corrade::Containers::arrayAppend(Array<T>& array, const T& value) new in 2020.06

Copy-append an item to an array.

If the array is not growable or the capacity is not large enough, the array capacity is grown first. Then, value is copy-constructed at the end of the array and Array::size() increased by 1.

Amortized complexity is providing the allocator growth ratio is exponential.

#include <Corrade/Containers/GrowableArray.h>

template<class T, class... Args>

T& Corrade::Containers::arrayAppend(Array<T>& array, InPlaceInitT, Args && ... args) new in 2020.06

In-place append an item to an array.

Similar to arrayAppend(Array<T>&, const T&) except that the new element is constructed using placement-new with provided args.

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

T& Corrade::Containers::arrayAppend(Array<T>& array, T&& value) new in 2020.06

Move-append an item to an array.

Calls arrayAppend(Array<T>&, InPlaceInitT, Args&&... args) with value.

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

Containers::ArrayView<T> Corrade::Containers::arrayAppend(Array<T>& array, Containers::ArrayView<const T> values) new in 2020.06

Append a list of items to an array.

Like arrayAppend(Array<T>&, const T&), but inserting multiple values at once.

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

Containers::ArrayView<T> Corrade::Containers::arrayAppend(Array<T>& array, std::initializer_list<T> values) new in 2020.06

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

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

Containers::ArrayView<T> Corrade::Containers::arrayAppend(Array<T>& array, NoInitT, std::size_t count) new in 2020.06

Append given count of uninitialized values to the array.

A lower-level variant of arrayAppend(Array<T>& array, Containers::ArrayView<const T>) where the new values are meant to be initialized in-place after, instead of being copied from a pre-existing location.

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

void Corrade::Containers::arrayRemoveSuffix(Array<T>& array, std::size_t count = 1) new in 2020.06

Remove a suffix from the array.

Expects that count is not larger than Array::size(). If the array is not growable, all its elements except the suffix are first reallocated to a growable version. Otherwise, a destructor is called on removed elements and the Array::size() is decreased by count.

#include <Corrade/Containers/GrowableArray.h>

template<class T, class Allocator = ArrayAllocator<T>>

void Corrade::Containers::arrayShrink(Array<T>& array) new in 2020.06

Convert an array back to non-growable.

Allocates memory that's exactly large enough to fit Array::size() elements, move-constructs the elements there and frees the old memory using Array::deleter(). If the array is not growable, it's assumed to be already as small as possible, and nothing is done.

Complexity is at most in the size of the container, if the array is already non-growable.

NullOptT Corrade::Containers::NullOpt constexpr

#include <Corrade/Containers/Optional.h>

Null optional initialization tag.

Use for explicit initialization of null Optional.

AllocatedInitT Corrade::Containers::AllocatedInit constexpr new in Git master

#include <Corrade/Containers/String.h>

Allocated initialization tag.

Use for String construction that bypasses small string optimization. Small string optimization

DefaultInitT Corrade::Containers::DefaultInit constexpr

#include <Corrade/Containers/Tags.h>

Default initialization tag.

Use for construction using default initialization (builtin types are not initialized, others are default-constructed).

ValueInitT Corrade::Containers::ValueInit constexpr

#include <Corrade/Containers/Tags.h>

Value initialization tag.

Use for construction using value initialization (builtin types are zeroed out, others are default-constructed).

NoInitT Corrade::Containers::NoInit constexpr

#include <Corrade/Containers/Tags.h>

No initialization tag.

Use for construction with no initialization at all.

NoCreateT Corrade::Containers::NoCreate constexpr

#include <Corrade/Containers/Tags.h>

No creation tag.

Use for construction with initialization, but keeping the instance empty (usually equivalent to a moved-out state).

DirectInitT Corrade::Containers::DirectInit constexpr

#include <Corrade/Containers/Tags.h>

Direct initialization tag.

Use for construction with direct initialization.

InPlaceInitT Corrade::Containers::InPlaceInit constexpr

#include <Corrade/Containers/Tags.h>

In-place initialization tag.

Use for construction in-place.