aws-crt-cpp
C++ wrapper around the aws-c-* libraries. Provides Cross-Platform Transport Protocols and SSL/TLS implementations for C++.
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
Aws::Crt Namespace Reference

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
 
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
 
class  VariantAlternative
 
class  VariantSize
 

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 = std::unordered_map< K, V, std::hash< K >, std::equal_to< K >, StlAllocator< std::pair< const K, V > > >
 
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
 
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)
 

Variables

AWS_CRT_CPP_API Allocator * g_allocator = Aws::Crt::DefaultAllocatorImplementation()
 
static constexpr InPlaceT InPlace {}
 
static Crypto::CreateHashCallback s_BYOCryptoNewMD5Callback
 
static Crypto::CreateHashCallback s_BYOCryptoNewSHA256Callback
 
static Crypto::CreateHashCallback s_BYOCryptoNewSHA1Callback
 
static Crypto::CreateHMACCallback s_BYOCryptoNewSHA256HMACCallback
 
static Io::NewClientTlsHandlerCallback s_BYOCryptoNewClientTlsHandlerCallback
 
static Io::NewTlsContextImplCallback s_BYOCryptoNewTlsContextImplCallback
 
static Io::DeleteTlsContextImplCallback s_BYOCryptoDeleteTlsContextImplCallback
 
static Io::IsTlsAlpnSupportedCallback s_BYOCryptoIsTlsAlpnSupportedCallback
 

Typedef Documentation

◆ Allocator

using Aws::Crt::Allocator = typedef aws_allocator

◆ ByteBuf

using Aws::Crt::ByteBuf = typedef aws_byte_buf

◆ ByteCursor

using Aws::Crt::ByteCursor = typedef aws_byte_cursor

◆ List

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

◆ Map

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

◆ MultiMap

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

◆ ScopedResource

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

◆ String

using Aws::Crt::String = typedef 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 = typedef std::basic_stringstream<char, std::char_traits<char>, StlAllocator<char> >

◆ StringView

using Aws::Crt::StringView = typedef string_view

◆ TypeConvertor

template<typename RawType , typename TargetType >
using Aws::Crt::TypeConvertor = typedef 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 = typedef std::unordered_map<K, V, std::hash<K>, std::equal_to<K>, StlAllocator<std::pair<const K, V> >>

◆ Vector

template<typename T >
using Aws::Crt::Vector = typedef 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 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() [2/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() [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
errorerror 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
strstring 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 
)

◆ New()

template<typename T , typename... Args>
T * Aws::Crt::New ( Allocator *  allocator,
Args &&...  args 
)

◆ operator!=() [1/3]

template<class CharT , class Traits >
bool Aws::Crt::operator!= ( const basic_string_view< CharT, Traits > &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
noexcept

◆ operator!=() [2/3]

template<class CharT , class Traits >
bool Aws::Crt::operator!= ( const basic_string_view< CharT, Traits > &  lhs,
typename std::common_type< basic_string_view< CharT, Traits > >::type &  rhs 
)
noexcept

◆ operator!=() [3/3]

template<class CharT , class Traits >
bool Aws::Crt::operator!= ( typename std::common_type< basic_string_view< CharT, Traits > >::type &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
noexcept

◆ operator<() [1/3]

template<class CharT , class Traits >
bool Aws::Crt::operator< ( const basic_string_view< CharT, Traits > &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
noexcept

◆ operator<() [2/3]

template<class CharT , class Traits >
constexpr bool Aws::Crt::operator< ( const basic_string_view< CharT, Traits > &  lhs,
typename std::common_type< basic_string_view< CharT, Traits > >::type &  rhs 
)
constexprnoexcept

◆ operator<() [3/3]

template<class CharT , class Traits >
constexpr bool Aws::Crt::operator< ( typename std::common_type< basic_string_view< CharT, Traits > >::type &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
constexprnoexcept

◆ operator<=() [1/3]

template<class CharT , class Traits >
constexpr bool Aws::Crt::operator<= ( const basic_string_view< CharT, Traits > &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
constexprnoexcept

◆ operator<=() [2/3]

template<class CharT , class Traits >
constexpr bool Aws::Crt::operator<= ( const basic_string_view< CharT, Traits > &  lhs,
typename std::common_type< basic_string_view< CharT, Traits > >::type &  rhs 
)
constexprnoexcept

◆ operator<=() [3/3]

template<class CharT , class Traits >
constexpr bool Aws::Crt::operator<= ( typename std::common_type< basic_string_view< CharT, Traits > >::type &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
constexprnoexcept

◆ operator==() [1/3]

template<class CharT , class Traits >
bool Aws::Crt::operator== ( const basic_string_view< CharT, Traits > &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
noexcept

◆ operator==() [2/3]

template<class CharT , class Traits >
bool Aws::Crt::operator== ( const basic_string_view< CharT, Traits > &  lhs,
typename std::common_type< basic_string_view< CharT, Traits > >::type &  rhs 
)
noexcept

◆ operator==() [3/3]

template<class CharT , class Traits >
bool Aws::Crt::operator== ( typename std::common_type< basic_string_view< CharT, Traits > >::type &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
noexcept

◆ operator>() [1/3]

template<class CharT , class Traits >
constexpr bool Aws::Crt::operator> ( const basic_string_view< CharT, Traits > &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
constexprnoexcept

◆ operator>() [2/3]

template<class CharT , class Traits >
constexpr bool Aws::Crt::operator> ( const basic_string_view< CharT, Traits > &  lhs,
typename std::common_type< basic_string_view< CharT, Traits > >::type &  rhs 
)
constexprnoexcept

◆ operator>() [3/3]

template<class CharT , class Traits >
constexpr bool Aws::Crt::operator> ( typename std::common_type< basic_string_view< CharT, Traits > >::type &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
constexprnoexcept

◆ operator>=() [1/3]

template<class CharT , class Traits >
constexpr bool Aws::Crt::operator>= ( const basic_string_view< CharT, Traits > &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
constexprnoexcept

◆ operator>=() [2/3]

template<class CharT , class Traits >
constexpr bool Aws::Crt::operator>= ( const basic_string_view< CharT, Traits > &  lhs,
typename std::common_type< basic_string_view< CharT, Traits > >::type &  rhs 
)
constexprnoexcept

◆ operator>=() [3/3]

template<class CharT , class Traits >
constexpr bool Aws::Crt::operator>= ( typename std::common_type< basic_string_view< CharT, Traits > >::type &  lhs,
const basic_string_view< CharT, Traits > &  rhs 
)
constexprnoexcept

◆ StringViewToByteCursor()

AWS_CRT_CPP_API ByteCursor Aws::Crt::StringViewToByteCursor ( const StringView &  sv)
inline

Variable Documentation

◆ g_allocator

Allocator * Aws::Crt::g_allocator = Aws::Crt::DefaultAllocatorImplementation()
Deprecated:
Use ApiAllocator() instead, to avoid issues with delay-loaded DLLs. https://github.com/aws/aws-sdk-cpp/issues/1960

◆ InPlace

constexpr InPlaceT Aws::Crt::InPlace {}
staticconstexpr

◆ s_BYOCryptoDeleteTlsContextImplCallback

Io::DeleteTlsContextImplCallback Aws::Crt::s_BYOCryptoDeleteTlsContextImplCallback
static

◆ s_BYOCryptoIsTlsAlpnSupportedCallback

Io::IsTlsAlpnSupportedCallback Aws::Crt::s_BYOCryptoIsTlsAlpnSupportedCallback
static

◆ s_BYOCryptoNewClientTlsHandlerCallback

Io::NewClientTlsHandlerCallback Aws::Crt::s_BYOCryptoNewClientTlsHandlerCallback
static

◆ s_BYOCryptoNewMD5Callback

Crypto::CreateHashCallback Aws::Crt::s_BYOCryptoNewMD5Callback
static

◆ s_BYOCryptoNewSHA1Callback

Crypto::CreateHashCallback Aws::Crt::s_BYOCryptoNewSHA1Callback
static

◆ s_BYOCryptoNewSHA256Callback

Crypto::CreateHashCallback Aws::Crt::s_BYOCryptoNewSHA256Callback
static

◆ s_BYOCryptoNewSHA256HMACCallback

Crypto::CreateHMACCallback Aws::Crt::s_BYOCryptoNewSHA256HMACCallback
static

◆ s_BYOCryptoNewTlsContextImplCallback

Io::NewTlsContextImplCallback Aws::Crt::s_BYOCryptoNewTlsContextImplCallback
static
Generated by doxygen 1.9.8