Container.hpp File Reference

#include <array>
#include <bitset>
#include <list>
#include <map>
#include <numeric>
#include <optional>
#include <queue>
#include <set>
#include <span>
#include <string>
#include <string_view>
#include <vector>
#include "Allocator.hpp"

Go to the source code of this file.

Classes
class	Foundation::Core::Span< T >
	std::span with relaxed constructors for pointer-aliasing types and common containers. More...

Namespaces
namespace	Foundation
namespace	Foundation::Core
	Allocators, Data Structures and introspection implementations.

Typedefs
template<typename T >
using	Foundation::Core::Optional = std::optional< T >
	Alias for std::optional
template<typename First , typename Second >
using	Foundation::Core::Pair = std::pair< First, Second >
	Alias for std::pair
template<typename ... Args>
using	Foundation::Core::Tuple = std::tuple< Args... >
	Alias for std::tuple
template<typename T , size_t Size>
using	Foundation::Core::Array = std::array< T, Size >
	Alias for std::array
template<size_t Size>
using	Foundation::Core::Bitset = std::bitset< Size >
	Alias for std::bitset
using	Foundation::Core::StringView = std::basic_string_view< char >
	Alias for std::basic_string_view<char>
using	Foundation::Core::String = std::basic_string< char >
	Alias for std::basic_string<char>, without an explicit allocator constructor.
using	Foundation::Core::StringAlloc = std::basic_string< char, std::char_traits< char >, StlAllocator< char > >
	std::basic_string<char> with explicit Foundation::Core::StlAllocator constructor
template<typename T >
using	Foundation::Core::Vector = std::vector< T, StlAllocator< T > >
	std::vector with explicit Foundation::Core::StlAllocator constructor
template<typename T , typename Predicate = std::less<T>>
using	Foundation::Core::Set = std::set< T, Predicate, StlAllocator< T > >
	std::set with explicit Foundation::Core::StlAllocator constructor
template<typename K , typename V , typename Predicate = std::less<K>>
using	Foundation::Core::Map = std::map< K, V, Predicate, StlAllocator< Pair< const K, V > > >
	std::map with explicit Foundation::Core::StlAllocator constructor
template<typename T >
using	Foundation::Core::Deque = std::deque< T, StlAllocator< T > >
	std::deque with explicit Foundation::Core::StlAllocator constructor
template<typename T >
using	Foundation::Core::List = std::list< T, StlAllocator< T > >
	std::list with explicit Foundation::Core::StlAllocator constructor
template<typename T , typename Container = Deque<T>>
using	Foundation::Core::Queue = std::queue< T, Container >
	std::queue with explicit Foundation::Core::StlAllocator constructor
template<typename T , typename Predicate = std::less<T>, typename Container = Vector<T>>
using	Foundation::Core::PriorityQueue = std::priority_queue< T, Container, Predicate >
	std::priority_queue with explicit Foundation::Core::StlAllocator constructor

Functions
template<typename T , typename ... Args>
Span< T >	Foundation::Core::ConstructSpan (Allocator *resource, size_t size, Args &&...args)
	Convenience function for constructing a Span with memory allocated from a Foundation::Core::Allocator. Possibly constructs objects in-place if they are not trivially constructible (e.g. non-PODs)
template<typename T >
void	Foundation::Core::DestructSpan (Allocator *resource, Span< T > span)
	Convenience function for destructing a Span allocated with ConstructSpan. Calls destructors in-place if the type is not trivially destructible (e.g. non-PODs)