Namespaces
namespace	Auth
namespace	Cbor
namespace	Checksum
namespace	Crypto
namespace	DnsUtils
namespace	Endpoints
namespace	Http
namespace	Imds
namespace	Io
namespace	literals
namespace	Mqtt
namespace	Mqtt5
namespace	string_view_literals
namespace	VariantDetail

Classes
class	ApiHandle
class	basic_string_view
struct	Conjunction
struct	Conjunction< Arg, Args... >
class	DateTime
struct	InPlaceT
struct	InPlaceTypeT
struct	IsSpecializationOf
struct	IsSpecializationOf< Primary< Args... >, Primary >
class	JsonObject
class	JsonView
class	Optional
class	RefCounted
class	StlAllocator
class	UUID
class	Variant

Typedefs
using	Allocator = aws_allocator
typedef basic_string_view< char >	string_view
typedef basic_string_view< char16_t >	u16string_view
typedef basic_string_view< char32_t >	u32string_view
typedef basic_string_view< wchar_t >	wstring_view
using	StringView = string_view
using	ByteBuf = aws_byte_buf
using	ByteCursor = aws_byte_cursor
using	String = std::basic_string<char, std::char_traits<char>, StlAllocator<char>>
using	StringStream = std::basic_stringstream<char, std::char_traits<char>, StlAllocator<char>>
template<typename K, typename V>
using	Map = std::map<K, V, std::less<K>, StlAllocator<std::pair<const K, V>>>
template<typename K, typename V>
using	UnorderedMap
template<typename K, typename V>
using	MultiMap = std::multimap<K, V, std::less<K>, StlAllocator<std::pair<const K, V>>>
template<typename T>
using	Vector = std::vector<T, StlAllocator<T>>
template<typename T>
using	List = std::list<T, StlAllocator<T>>
template<typename RawType, typename TargetType>
using	TypeConvertor = std::function<TargetType(RawType)>
template<typename T>
using	ScopedResource = std::unique_ptr<T, std::function<void(T *)>>

Enumerations
enum class	LogLevel { None = AWS_LL_NONE , Fatal = AWS_LL_FATAL , Error = AWS_LL_ERROR , Warn = AWS_LL_WARN , Info = AWS_LL_INFO , Debug = AWS_LL_DEBUG , Trace = AWS_LL_TRACE , Count }
enum class	ApiHandleShutdownBehavior { Blocking , NonBlocking }
enum class	DateFormat { RFC822 = AWS_DATE_FORMAT_RFC822 , ISO_8601 = AWS_DATE_FORMAT_ISO_8601 , AutoDetect = AWS_DATE_FORMAT_AUTO_DETECT }
enum class	Month { January = AWS_DATE_MONTH_JANUARY , February = AWS_DATE_MONTH_FEBRUARY , March = AWS_DATE_MONTH_MARCH , April = AWS_DATE_MONTH_APRIL , May = AWS_DATE_MONTH_MAY , June = AWS_DATE_MONTH_JUNE , July = AWS_DATE_MONTH_JULY , August = AWS_DATE_MONTH_AUGUST , September = AWS_DATE_MONTH_SEPTEMBER , October = AWS_DATE_MONTH_OCTOBER , November = AWS_DATE_MONTH_NOVEMBER , December = AWS_DATE_MONTH_DECEMBER }
enum class	DayOfWeek { Sunday = AWS_DATE_DAY_OF_WEEK_SUNDAY , Monday = AWS_DATE_DAY_OF_WEEK_MONDAY , Tuesday = AWS_DATE_DAY_OF_WEEK_TUESDAY , Wednesday = AWS_DATE_DAY_OF_WEEK_WEDNESDAY , Thursday = AWS_DATE_DAY_OF_WEEK_THURSDAY , Friday = AWS_DATE_DAY_OF_WEEK_FRIDAY , Saturday = AWS_DATE_DAY_OF_WEEK_SATURDAY }

Functions
AWS_CRT_CPP_API Allocator *	ApiAllocator () noexcept
AWS_CRT_CPP_API Allocator *	DefaultAllocatorImplementation () noexcept
AWS_CRT_CPP_API Allocator *	DefaultAllocator () noexcept
AWS_CRT_CPP_API const char *	ErrorDebugString (int error) noexcept
AWS_CRT_CPP_API int	LastError () noexcept
AWS_CRT_CPP_API int	LastErrorOrUnknown () noexcept
size_t AWS_CRT_CPP_API	HashString (const char *str) noexcept
template<class CharT, class Traits>
bool	operator== (const basic_string_view< CharT, Traits > &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
template<class CharT, class Traits>
bool	operator== (const basic_string_view< CharT, Traits > &lhs, typename std::common_type< basic_string_view< CharT, Traits > >::type &rhs) noexcept
template<class CharT, class Traits>
bool	operator== (typename std::common_type< basic_string_view< CharT, Traits > >::type &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
template<class CharT, class Traits>
bool	operator!= (const basic_string_view< CharT, Traits > &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
template<class CharT, class Traits>
bool	operator!= (const basic_string_view< CharT, Traits > &lhs, typename std::common_type< basic_string_view< CharT, Traits > >::type &rhs) noexcept
template<class CharT, class Traits>
bool	operator!= (typename std::common_type< basic_string_view< CharT, Traits > >::type &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
template<class CharT, class Traits>
bool	operator< (const basic_string_view< CharT, Traits > &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
template<class CharT, class Traits>
constexpr bool	operator< (const basic_string_view< CharT, Traits > &lhs, typename std::common_type< basic_string_view< CharT, Traits > >::type &rhs) noexcept
template<class CharT, class Traits>
constexpr bool	operator< (typename std::common_type< basic_string_view< CharT, Traits > >::type &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
template<class CharT, class Traits>
constexpr bool	operator> (const basic_string_view< CharT, Traits > &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
template<class CharT, class Traits>
constexpr bool	operator> (const basic_string_view< CharT, Traits > &lhs, typename std::common_type< basic_string_view< CharT, Traits > >::type &rhs) noexcept
template<class CharT, class Traits>
constexpr bool	operator> (typename std::common_type< basic_string_view< CharT, Traits > >::type &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
template<class CharT, class Traits>
constexpr bool	operator<= (const basic_string_view< CharT, Traits > &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
template<class CharT, class Traits>
constexpr bool	operator<= (const basic_string_view< CharT, Traits > &lhs, typename std::common_type< basic_string_view< CharT, Traits > >::type &rhs) noexcept
template<class CharT, class Traits>
constexpr bool	operator<= (typename std::common_type< basic_string_view< CharT, Traits > >::type &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
template<class CharT, class Traits>
constexpr bool	operator>= (const basic_string_view< CharT, Traits > &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
template<class CharT, class Traits>
constexpr bool	operator>= (const basic_string_view< CharT, Traits > &lhs, typename std::common_type< basic_string_view< CharT, Traits > >::type &rhs) noexcept
template<class CharT, class Traits>
constexpr bool	operator>= (typename std::common_type< basic_string_view< CharT, Traits > >::type &lhs, const basic_string_view< CharT, Traits > &rhs) noexcept
basic_string_view< char >	OPERATOR_LITERAL_SV (const char *s, size_t length) noexcept
basic_string_view< wchar_t >	OPERATOR_LITERAL_SV (const wchar_t *s, size_t length) noexcept
basic_string_view< char16_t >	OPERATOR_LITERAL_SV (const char16_t *s, size_t length) noexcept
basic_string_view< char32_t >	OPERATOR_LITERAL_SV (const char32_t *s, size_t length) noexcept
AWS_CRT_CPP_API ByteBuf	ByteBufFromCString (const char *str) noexcept
AWS_CRT_CPP_API ByteBuf	ByteBufFromEmptyArray (const uint8_t *array, size_t len) noexcept
AWS_CRT_CPP_API ByteBuf	ByteBufFromArray (const uint8_t *array, size_t capacity) noexcept
AWS_CRT_CPP_API ByteBuf	ByteBufNewCopy (Allocator alloc, const uint8_t array, size_t len)
AWS_CRT_CPP_API ByteBuf	ByteBufInit (Allocator *alloc, size_t len)
AWS_CRT_CPP_API void	ByteBufDelete (ByteBuf &)
AWS_CRT_CPP_API ByteCursor	ByteCursorFromCString (const char *str) noexcept
AWS_CRT_CPP_API ByteCursor	ByteCursorFromString (const Crt::String &str) noexcept
AWS_CRT_CPP_API ByteCursor	ByteCursorFromStringView (const Crt::StringView &str) noexcept
AWS_CRT_CPP_API ByteCursor	ByteCursorFromByteBuf (const ByteBuf &) noexcept
AWS_CRT_CPP_API ByteCursor	ByteCursorFromArray (const uint8_t *array, size_t len) noexcept
AWS_CRT_CPP_API Vector< uint8_t >	Base64Decode (const String &decode) noexcept
AWS_CRT_CPP_API String	Base64Encode (const Vector< uint8_t > &encode) noexcept
template<typename RawType, typename TargetType>
Vector< TargetType >	ArrayListToVector (const aws_array_list *array, TypeConvertor< RawType, TargetType > conv)
template<typename RawType, typename TargetType>
Vector< TargetType >	ArrayListToVector (const aws_array_list *array)
template<typename Type>
Vector< Type >	ArrayListToVector (const aws_array_list *array)
AWS_CRT_CPP_API StringView	ByteCursorToStringView (const ByteCursor &bc)
AWS_CRT_CPP_API ByteCursor	StringViewToByteCursor (const StringView &sv)
template<typename T>
void	Delete (T t, Allocator allocator)
template<typename T, typename... Args>
T *	New (Allocator *allocator, Args &&...args)
template<typename T, typename... Args>
std::shared_ptr< T >	MakeShared (Allocator *allocator, Args &&...args)
template<typename Derived, typename Base, typename std::enable_if< std::is_base_of< Base, Derived >::value, bool >::type = true>
ScopedResource< Base >	SafeSuperCast (ScopedResource< Derived > derived)
template<typename Base, typename Derived, typename std::enable_if< std::is_base_of< Base, Derived >::value, bool >::type = true>
ScopedResource< Derived >	SafeSubCast (ScopedResource< Base > base)

Typedef Documentation

◆ Allocator

using Aws::Crt::Allocator = aws_allocator

◆ ByteBuf

using Aws::Crt::ByteBuf = aws_byte_buf

◆ ByteCursor

using Aws::Crt::ByteCursor = aws_byte_cursor

◆ List

template<typename T>

using Aws::Crt::List = std::list<T, StlAllocator<T>>

◆ Map

template<typename K, typename V>

using Aws::Crt::Map = std::map<K, V, std::less<K>, StlAllocator<std::pair<const K, V>>>

◆ MultiMap

template<typename K, typename V>

using Aws::Crt::MultiMap = std::multimap<K, V, std::less<K>, StlAllocator<std::pair<const K, V>>>

◆ ScopedResource

template<typename T>

using Aws::Crt::ScopedResource = std::unique_ptr<T, std::function<void(T *)>>

◆ String

using Aws::Crt::String = std::basic_string<char, std::char_traits<char>, StlAllocator<char>>

◆ string_view

typedef basic_string_view<char> Aws::Crt::string_view

◆ StringStream

using Aws::Crt::StringStream = std::basic_stringstream<char, std::char_traits<char>, StlAllocator<char>>

◆ StringView

using Aws::Crt::StringView = string_view

◆ TypeConvertor

template<typename RawType, typename TargetType>

using Aws::Crt::TypeConvertor = std::function<TargetType(RawType)>

◆ u16string_view

typedef basic_string_view<char16_t> Aws::Crt::u16string_view

◆ u32string_view

typedef basic_string_view<char32_t> Aws::Crt::u32string_view

◆ UnorderedMap

template<typename K, typename V>

using Aws::Crt::UnorderedMap

Initial value:

std::unordered_map<K, V, std::hash<K>, std::equal_to<K>, StlAllocator<std::pair<const K, V>>>

Aws::Crt::StlAllocator

Definition StlAllocator.h:21

◆ Vector

template<typename T>

using Aws::Crt::Vector = std::vector<T, StlAllocator<T>>

◆ wstring_view

typedef basic_string_view<wchar_t> Aws::Crt::wstring_view

Enumeration Type Documentation

◆ ApiHandleShutdownBehavior

enum class Aws::Crt::ApiHandleShutdownBehavior

strong

Should the API Handle destructor block on all shutdown/thread completion logic or not?

Enumerator
Blocking
NonBlocking

◆ DateFormat

enum class Aws::Crt::DateFormat

strong

Enumerator
RFC822
ISO_8601
AutoDetect

◆ DayOfWeek

enum class Aws::Crt::DayOfWeek

strong

Enumerator
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday

◆ LogLevel

enum class Aws::Crt::LogLevel

strong

Detail level control for logging output

Enumerator
None
Fatal
Error
Warn
Info
Debug
Trace
Count

◆ Month

enum class Aws::Crt::Month

strong

Enumerator
January
February
March
April
May
June
July
August
September
October
November
December

Function Documentation

◆ ApiAllocator()

Allocator * Aws::Crt::ApiAllocator ( )

noexcept

Each object from this library can use an explicit allocator. If you construct an object without specifying an allocator, then THIS allocator is used instead.

You can customize this allocator when initializing ApiHandle.

◆ ArrayListToVector() [1/3]

template<typename Type>

Vector< Type > Aws::Crt::ArrayListToVector ( const aws_array_list * array )

Template function to convert an aws_array_list of Type to a C++ like Vector of Type.

◆ ArrayListToVector() [2/3]

template<typename RawType, typename TargetType>

Vector< TargetType > Aws::Crt::ArrayListToVector ( const aws_array_list * array )

Template function to convert an aws_array_list of RawType to a C++ like Vector of TargetType. This template assumes a direct constructor: TargetType(RawType) is available

◆ ArrayListToVector() [3/3]

template<typename RawType, typename TargetType>

Vector< TargetType > Aws::Crt::ArrayListToVector	(	const aws_array_list *	array,
		TypeConvertor< RawType, TargetType >	conv )

Template function to convert an aws_array_list of RawType to a C++ like Vector of TargetType. A conversion function should be provided to do the type conversion

◆ Base64Decode()

Vector< uint8_t > Aws::Crt::Base64Decode ( const String & decode )

noexcept

◆ Base64Encode()

String Aws::Crt::Base64Encode ( const Vector< uint8_t > & encode )

noexcept

◆ ByteBufDelete()

void Aws::Crt::ByteBufDelete ( ByteBuf & buf )

◆ ByteBufFromArray()

ByteBuf Aws::Crt::ByteBufFromArray	(	const uint8_t *	array,
		size_t	capacity )

noexcept

◆ ByteBufFromCString()

ByteBuf Aws::Crt::ByteBufFromCString ( const char * str )

noexcept

◆ ByteBufFromEmptyArray()

ByteBuf Aws::Crt::ByteBufFromEmptyArray	(	const uint8_t *	array,
		size_t	len )

noexcept

◆ ByteBufInit()

ByteBuf Aws::Crt::ByteBufInit	(	Allocator *	alloc,
		size_t	len )

◆ ByteBufNewCopy()

ByteBuf Aws::Crt::ByteBufNewCopy	(	Allocator *	alloc,
		const uint8_t *	array,
		size_t	len )

◆ ByteCursorFromArray()

ByteCursor Aws::Crt::ByteCursorFromArray	(	const uint8_t *	array,
		size_t	len )

noexcept

◆ ByteCursorFromByteBuf()

ByteCursor Aws::Crt::ByteCursorFromByteBuf ( const ByteBuf & buf )

noexcept

◆ ByteCursorFromCString()

ByteCursor Aws::Crt::ByteCursorFromCString ( const char * str )

noexcept

◆ ByteCursorFromString()

ByteCursor Aws::Crt::ByteCursorFromString ( const Crt::String & str )

noexcept

◆ ByteCursorFromStringView()

ByteCursor Aws::Crt::ByteCursorFromStringView ( const Crt::StringView & str )

noexcept

◆ ByteCursorToStringView()

AWS_CRT_CPP_API StringView Aws::Crt::ByteCursorToStringView ( const ByteCursor & bc )

inline

◆ DefaultAllocator()

Allocator * Aws::Crt::DefaultAllocator ( )

noexcept

Deprecated: Use DefaultAllocatorImplementation() instead. DefaultAllocator() is too easily confused with ApiAllocator().

◆ DefaultAllocatorImplementation()

Allocator * Aws::Crt::DefaultAllocatorImplementation ( )

noexcept

Returns the default implementation of an Allocator.

If you initialize ApiHandle without specifying a custom allocator, then this implementation is used.

◆ Delete()

template<typename T>

void Aws::Crt::Delete	(	T *	t,
		Allocator *	allocator )

◆ ErrorDebugString()

const char * Aws::Crt::ErrorDebugString ( int error )

noexcept

Gets a string description of a CRT error code

Parameters

error error code to get a descriptive string for

Returns: a string description of the error code

◆ HashString()

size_t Aws::Crt::HashString ( const char * str )

noexcept

C-string hash function

Parameters

str	string to hash

Returns: hash code of the string

◆ LastError()

int Aws::Crt::LastError ( )

noexcept

Returns: the value of the last aws error on the current thread. Return 0 if no aws-error raised before.

◆ LastErrorOrUnknown()

int Aws::Crt::LastErrorOrUnknown ( )

noexcept

Returns: the value of the last aws error on the current thread. Return AWS_ERROR_UNKNOWN, if no aws-error raised before.

◆ MakeShared()

template<typename T, typename... Args>

std::shared_ptr< T > Aws::Crt::MakeShared	(	Allocator *	allocator,
		Args &&...	args )