Namespaces
namespace	Api

namespace	Base64Opts

namespace	CryptoConstants

namespace	CursorOp

namespace	DecryptKeyExportErrorCodes

namespace	detail

namespace	Factory

namespace	PromiseCombination

namespace	VerificationCancelCodes

namespace	VerificationEventTypes

namespace	VerificationProcessStates

namespace	VerificationUtils

Classes
class	AbstractPromise

struct	AddAccountDataAction

struct	AddEphemeralAction

struct	AddLocalEchoAction

struct	AddLocalNotificationsAction
	Update local notifications to include the new events. More...

struct	AddMessagesAction
	Add events to the messages map, but not the timeline. More...

struct	AddPendingRoomKeyAction

struct	AddStateEventsAction

struct	AddToTimelineAction

class	AES256CTRDesc

class	AsioPromise

class	AsioPromiseHandler

class	AsioStdFileHandler

class	AsioStdFileProvider

class	AsioStdFileStream

struct	BanAction

class	BaseJob

struct	ChangeInviteStateAction

struct	ChangeMembershipAction

struct	ClaimKeysAction

class	Client
	Represent a Matrix client. More...

struct	ClientModel

class	ContextBase

struct	CprJobHandler

struct	CreateRoomAction

class	Crypto

struct	CryptoPrivate

struct	DeviceKeyInfo

struct	DeviceListTracker

struct	DownloadContentAction

struct	DownloadThumbnailAction

class	DumbFileInterface

struct	DumbFileProvider

struct	DumbFileStream

class	EffectBase

class	EffectStatus

struct	EmptyBody

class	EncryptedFileDesc

struct	EncryptMegOlmEventAction
	The action to encrypt an megolm event for a room. More...

struct	EnsureKeysFromDevicesAction
	Ensure keys from devices of a user. More...

class	Event

class	EventInterface

struct	EventReader

class	FileDesc

class	FileInterface

class	FileProvider

class	FileStream

struct	ForgetRoomAction

struct	GenerateAndUploadOneTimeKeysAction
	The action to generate one-time keys. More...

class	GetContentJobV1

struct	GetRoomStatesAction

struct	GetStateEventAction

struct	GetUserProfileAction

struct	GetVersionsAction

struct	GetWellknownAction

struct	HardLogoutAction

struct	ImportFromKeyBackupFileAction
	Import keys from key backup file. More...

class	InboundGroupSession

struct	InboundGroupSessionPrivate

struct	InboundSessionTag

struct	InviteToRoomAction

struct	JobInterface

struct	JoinRoomAction

struct	JoinRoomByIdAction

class	JsonWrap

struct	KeyOfDecryptedEvent

struct	KeyOfGroupSession

struct	KeyOfOutboundSession

struct	KeyOfState

struct	KickAction

class	LagerStoreEventEmitter

struct	LeaveRoomAction

struct	LoadEventsFromStorageAction
	Load events from the storage into the model. More...

struct	LocalDraft
	Local draft. More...

struct	LocalEchoDesc
	Describes a local echo. More...

struct	LoginAction

struct	LoginFailed

struct	LoginSuccessful

struct	LogoutAction

struct	MarkMembersFullyLoadedAction

class	Maybe

struct	MaybeAddStateEventsAction
	Go from the back of stateEvents to the beginning, adding the event to room state only if the room has no state event with that state key. More...

struct	MegOlmSessionRotateDesc

struct	MLoginTokenLoginAction
	Login using the m.token.login flow. More...

class	NotBut

class	NotificationHandler
	A class to handle a notification. More...

struct	NotifyVerificationTrackerModelAction
	Notify that the verification tracker model has been changed. More...

struct	Null

class	OutboundGroupSession

struct	OutboundGroupSessionPrivate

struct	OutboundSessionTag

struct	PaginateTimelineAction

struct	PendingRoomKeyEvent

struct	PopLocalDraftAction

struct	PostInitialFiltersAction

struct	PostReceiptAction

class	PowerLevelsDesc
	Represent a m.power_levels event. More...

struct	PrepareForSharingRoomKeyAction
	Encrypt room key as olm and add it to the room's pending keyshare slots. More...

struct	ProcessResponseAction

class	PromiseInterface

struct	PurgeEventsAction
	Remove events from the model, retaining only the latest `maxToKeep` events. More...

struct	PurgeRoomTimelineAction
	Remove events from the model, keeping only the latest `maxToKeep` events. More...

struct	PushAction
	Describe what actions are to be taken for a specific event. More...

struct	PushLocalDraftAction

class	PushRulesDesc

struct	PushRulesDescPrivate

struct	QueryKeysAction

class	RandomDeviceGenerator
	A movable wrapper around std::random_device. More...

class	RandomInterface

struct	RandomTag
	The tag to indicate that a constructor should use user-provided random data. More...

struct	ReadReceipt

struct	ReceivingAccountDataEvent

struct	ReceivingPresenceEvent

struct	ReceivingRoomAccountDataEvent

struct	ReceivingRoomStateEvent

struct	ReceivingRoomTimelineEvent

struct	ReceivingToDeviceMessage

struct	RedactEventAction

struct	RemoveLocalEchoAction

struct	RemovePendingRoomKeyAction

struct	RemoveReadLocalNotificationsAction
	Remove local notifications that are already read. More...

struct	RequestShareRoomSessionKeyAction

struct	Response

struct	ResubmitJobAction

class	Room
	Represent a Matrix room. More...

struct	RoomListModel

struct	RoomMembershipChanged

struct	RoomModel
	The model to store information about a room. More...

class	SasDesc

struct	SasDisplayCodes

struct	SaveEventsRequested
	Indicate that there are events to be saved. More...

struct	SaveLocalEchoAction
	Saves an local echo. More...

class	Sdk
	Contain the single source of truth of a matrix sdk. More...

struct	SdkModel

struct	SdkModelCursorTag

struct	SendMessageAction

struct	SendMultipleToDeviceMessagesAction
	Send multiple to device messages. More...

struct	SendStateEventAction

struct	SendToDeviceMessageAction

class	Session

struct	SessionPrivate

struct	SetAccountDataAction

struct	SetAccountDataPerRoomAction

struct	SetAvatarUrlAction

struct	SetDevicesTrustLevelsAction
	Set the trust levels of devices. More...

struct	SetDeviceTrustLevelAction

struct	SetDisplayNameAction

struct	SetHeroIdsAction

struct	SetLocalDraftAction

struct	SetLocalDraftRelAction

struct	SetLocalDraftTextAction

struct	SetReadMarkerAction

struct	SetRoomEncryptionAction

struct	SetShouldSyncAction

struct	SetTrustLevelNeededToSendKeysAction

struct	SetTypingAction

class	SHA256Desc

class	SingleTypePromise

class	SingleTypePromiseInterface

class	StoreBase

struct	SyncAction

struct	TokenLoginAction

class	TypelessPromise

struct	UnbanAction

struct	UnrecognizedResponse

struct	UpdateInvitedMemberCountAction

struct	UpdateJoinedMemberCountAction

struct	UpdateLocalEchoStatusAction
	Updates the status of an local echo. More...

struct	UpdateLocalReadMarkerAction
	Update the local read marker, removing any read notifications before it. More...

struct	UpdateRoomAction

struct	UploadContentAction

struct	UploadIdentityKeysAction

struct	VerificationProcess

struct	VerificationTracker
	A stateful tracker for all verification processes. More...

struct	VerificationTrackerModel
	A model that is suitable for displaying to the user. More...

struct	VerificationTrackerModelChanged

Typedefs
using	Header = immer::box< std::map< std::string, std::string > >

using	BytesBody = Bytes

using	JsonBody = JsonWrap

using	FileBody = FileDesc

using	Body = std::variant< EmptyBody, JsonBody, BytesBody, FileBody >

using	Timestamp = std::int_fast64_t

using	FileContent = immer::flex_vector< char >

using	json = nlohmann::json

using	KazvTrigger = std::variant< std::monostate, ReceivingPresenceEvent, ReceivingAccountDataEvent, ReceivingRoomTimelineEvent, ReceivingRoomStateEvent, RoomMembershipChanged, ReceivingRoomAccountDataEvent, ReceivingToDeviceMessage, LoginSuccessful, LoginFailed, SaveEventsRequested, VerificationTrackerModelChanged, UnrecognizedResponse >

using	KazvEvent = KazvTrigger

using	KazvTriggerList = immer::flex_vector< KazvTrigger >

using	KazvEventList = KazvTriggerList

using	MaybeString = Maybe< std::string >

template<class T , class P >
using	PromiseThenResult = typename detail::PromiseThenResultT< T, P >::type

using	BoolPromise = SingleTypePromise< bool >

using	BoolPromiseInterface = SingleTypePromiseInterface< bool >

using	Bytes = std::string

using	EventList = immer::flex_vector< Event >

using	Variant = std::variant< std::string, JsonWrap, Null >

using	ClientAction = std::variant< RoomListAction, LoginAction, TokenLoginAction, MLoginTokenLoginAction, LogoutAction, HardLogoutAction, GetWellknownAction, GetVersionsAction, SyncAction, SetShouldSyncAction, PostInitialFiltersAction, SetAccountDataAction, PaginateTimelineAction, SendMessageAction, SendStateEventAction, SaveLocalEchoAction, UpdateLocalEchoStatusAction, RedactEventAction, CreateRoomAction, GetRoomStatesAction, GetStateEventAction, InviteToRoomAction, JoinRoomByIdAction, JoinRoomAction, LeaveRoomAction, ForgetRoomAction, KickAction, BanAction, UnbanAction, SetAccountDataPerRoomAction, ProcessResponseAction, SetTypingAction, PostReceiptAction, SetReadMarkerAction, UploadContentAction, DownloadContentAction, DownloadThumbnailAction, SendToDeviceMessageAction, SendMultipleToDeviceMessagesAction, UploadIdentityKeysAction, GenerateAndUploadOneTimeKeysAction, QueryKeysAction, EnsureKeysFromDevicesAction, ClaimKeysAction, EncryptMegOlmEventAction, SetDeviceTrustLevelAction, SetDevicesTrustLevelsAction, SetTrustLevelNeededToSendKeysAction, PrepareForSharingRoomKeyAction, ImportFromKeyBackupFileAction, NotifyVerificationTrackerModelAction, RequestShareRoomSessionKeyAction, GetUserProfileAction, SetAvatarUrlAction, SetDisplayNameAction, ResubmitJobAction, LoadEventsFromStorageAction, PurgeRoomTimelineAction >

using	ClientEffect = Effect< ClientAction, lager::deps<> >

using	ClientResult = std::pair< ClientModel, ClientEffect >

using	PowerLevel = std::int_fast64_t

using	RoomAction = RoomModel::Action

using	RoomListAction = RoomListModel::Action

using	SdkModelCursorKey = lager::dep::key< SdkModelCursorTag, lager::dep::fn< std::shared_ptr< lager::reader< SdkModel > > > >

using	SdkAction = std::variant< ClientAction >

using	SdkEffect = Effect< SdkAction, lager::deps< JobInterface &, EventInterface & > >

using	SdkResult = std::pair< SdkModel, SdkEffect >

using	SessionList = std::vector< Session >

using	ByteArray = std::vector< unsigned char >

using	RandomData = std::string

using	VerificationProcessState = std::variant< std::monostate, VerificationProcessStates::WeRequested, VerificationProcessStates::TheyRequested, VerificationProcessStates::WeReady, VerificationProcessStates::TheyReady, VerificationProcessStates::WeStartedSas, VerificationProcessStates::TheyStartedSas, VerificationProcessStates::WeAcceptedSas, VerificationProcessStates::TheyAcceptedSas, VerificationProcessStates::ReceivedSasKey, VerificationProcessStates::ReceivedSasMac, VerificationProcessStates::VerifiedThem, VerificationProcessStates::VerifiedBoth, VerificationProcessStates::Cancelled >

using	DefaultRetType = EffectStatus

template<class A , class D = lager::deps<>>
using	Context = ContextBase< DefaultRetType, A, D >

template<class A , class D = lager::deps<>>
using	Effect = EffectBase< DefaultRetType, A, D >

template<class Action , class Model , class Reducer , class Deps = lager::deps<>, class Tag = lager::automatic_tag>
using	Store = StoreBase< Action, DefaultRetType, Model, Reducer, Deps, Tag >

Enumerations
enum	JobQueuePolicy { AlwaysContinue , CancelFutureIfFailed }

enum struct	FileOpRetCode { Error , Success , Eof }

enum struct	FileOpenMode { Read , Write }

enum	Status : bool { FAIL , SUCC }

enum	RoomMembership { Invite , Join , Leave }

enum class	CastArrayStrategy { IgnoreInvalid , FailAll }
	Strategy used for castArray(). More...

enum class	CastObjectStrategy { IgnoreInvalid , FailAll }
	Strategy used for castObject(). More...

enum	RoomVisibility { Private , Public }

enum	CreateRoomPreset { PrivateChat , PublicChat , TrustedPrivateChat }

enum	ThumbnailResizingMethod { Crop , Scale }

enum	DeviceTrustLevel { Blocked , Unseen , Seen , Verified }

Functions
template<class Exec >
	AsioStdFileHandler (Exec) -> AsioStdFileHandler< Exec >

bool	operator== (const BaseJob &a, const BaseJob &b)

bool	operator!= (const BaseJob &a, const BaseJob &b)

bool	isBodyJson (Body body)

template<class T >
void	addToQuery (BaseJob::Query &q, std::string name, T &&arg)

template<class T >
void	addToQueryIfNeeded (BaseJob::Query &q, std::string name, T &&arg)

template<class T , class V >
constexpr auto	jsonAtOr (T &&key, V &&defaultValue)

template<class Cursor , class ... Cursors>
constexpr auto	allCursors (Cursor &&first, Cursors &&...cursors)

auto	allCursors ()

template<class Cursor , class ... Cursors>
constexpr auto	anyCursor (Cursor &&first, Cursors &&...cursors)

auto	anyCursor ()

bool	operator== (const Event &a, const Event &b)

template<class T >
auto	getIn (T &&item)

template<class ImmerT , class K , class ... Keys>
auto	getIn (ImmerT &&container, K &&key, Keys &&...keys)

template<class T >
auto	setIn (T, T newVal)

template<class ImmerT , class K >
auto	setIn (ImmerT container, std::decay_t< decltype(getIn(std::declval< ImmerT >(), std::declval< K >()))> newVal, K &&key) -> std::decay_t< ImmerT >

template<class ImmerT , class K , class ... Keys>
auto	setIn (ImmerT container, std::decay_t< decltype(getIn(std::declval< ImmerT >(), std::declval< K >(), std::declval< Keys >()...))> newVal, K &&key, Keys &&...keys) -> std::decay_t< ImmerT >

template<class T , class Func >
auto	updateIn (T oldVal, Func func) -> T

template<class ImmerT , class Func , class ... Keys>
auto	updateIn (ImmerT container, Func func, Keys &&...keys) -> ImmerT

template<class ImmerT , class Func , class ValueT = typename ImmerT::value_type>
auto	withBox (ImmerT &box, Func &&func) -> std::decay_t< std::invoke_result_t< Func &&, ValueT & > >
	Do something with the box, updating its value, then return the return value of the function.

template<class ImmerT , class Key , class Func , class BoxT = typename ImmerT::mapped_type, class ValueT = typename BoxT::value_type>
auto	withMapBox (ImmerT &map, Key &&k, Func &&func) -> std::decay_t< std::invoke_result_t< Func &&, ValueT & > >

template<class Jsonish , class Key , class Func >
bool	hasAtThat (Jsonish &&j, Key &&k, Func &&f)

bool	isNonCompoundCanonicalJsonValue (const nlohmann::json &j)

template<class Jsonish , class RangeT >
std::optional< std::decay_t< Jsonish > >	getInJson (Jsonish &&j, RangeT &&path, std::size_t index=0)

template<class T >
void	addToJsonIfNeeded (json &j, std::string name, T &&arg)

template<class MapT , std::enable_if_t<!std::is_same_v< std::decay_t< MapT >, json > &&!std::is_same_v< std::decay_t< MapT >, JsonWrap >, int > = 0>
void	addPropertyMapToJson (json &j, MapT &&arg)

void	addPropertyMapToJson (json &j, const json &arg)

template<class Jsonish , class Key , class Validator >
bool	cast (Jsonish &ret, const Jsonish &input, Key &&k, Validator &&f)
	Run validator against `input[k]` and add it to `ret`.

template<class Func >
auto	identValidate (Func &&f)
	Make an identity validator.

template<class Jsonish , class Key , class Validator >
bool	castArray (Jsonish &ret, const Jsonish &input, Key &&k, Validator &&f, CastArrayStrategy strategy)
	Cast an array of items.

template<class Jsonish , class Key , class Validator >
bool	castObject (Jsonish &ret, const Jsonish &input, Key &&k, Validator &&f, CastObjectStrategy strategy)
	Cast an object of items.

template<class Jsonish , class Key , class Jsonish2 >
std::decay_t< Jsonish >	makeDefaultValue (Jsonish &&input, Key &&k, Jsonish2 &&defaultValue)
	Replace a non-existent value with a default one.

ClientResult	updateClient (ClientModel m, SetAccountDataPerRoomAction a)

ClientResult	processResponse (ClientModel m, SetAccountDataPerRoomResponse r)

ClientResult	updateClient (ClientModel m, SetAccountDataAction a)

ClientResult	processResponse (ClientModel m, SetAccountDataResponse r)

ClientResult	updateClient (ClientModel m, LoginAction a)

ClientResult	updateClient (ClientModel m, MLoginTokenLoginAction a)

ClientResult	processResponse (ClientModel m, LoginResponse r)

ClientResult	updateClient (ClientModel m, TokenLoginAction a)

ClientResult	updateClient (ClientModel m, LogoutAction)

ClientResult	updateClient (ClientModel m, HardLogoutAction)

ClientResult	processResponse (ClientModel m, LogoutResponse r)

ClientResult	updateClient (ClientModel m, GetWellknownAction a)

ClientResult	processResponse (ClientModel m, GetWellknownResponse r)

ClientResult	updateClient (ClientModel m, GetVersionsAction a)

ClientResult	processResponse (ClientModel m, GetVersionsResponse r)

std::pair< std::string, std::string >	mxcUriToMediaDesc (std::string mxcUri)

ClientResult	updateClient (ClientModel m, UploadContentAction a)

ClientResult	processResponse (ClientModel m, UploadContentResponse r)

ClientResult	updateClient (ClientModel m, DownloadContentAction a)

ClientResult	processResponse (ClientModel m, GetContentResponse r)

ClientResult	updateClient (ClientModel m, DownloadThumbnailAction a)

ClientResult	processResponse (ClientModel m, GetContentThumbnailResponse r)

ClientResult	updateClient (ClientModel m, UploadIdentityKeysAction)

ClientResult	updateClient (ClientModel m, GenerateAndUploadOneTimeKeysAction a)

ClientResult	processResponse (ClientModel m, UploadKeysResponse r)

Event	decryptEvent (ClientModel &m, Event e)

ClientModel	tryDecryptEvents (ClientModel m)

std::optional< BaseJob >	clientPerform (ClientModel m, QueryKeysAction a)

ClientResult	updateClient (ClientModel m, QueryKeysAction a)

ClientResult	updateClient (ClientModel m, EnsureKeysFromDevicesAction a)

ClientResult	processResponse (ClientModel m, QueryKeysResponse r)

ClientResult	updateClient (ClientModel m, ClaimKeysAction a)

ClientResult	processResponse (ClientModel m, ClaimKeysResponse r)

ClientResult	updateClient (ClientModel m, EncryptMegOlmEventAction a)

ClientResult	updateClient (ClientModel m, SetDeviceTrustLevelAction a)

ClientResult	updateClient (ClientModel m, SetDevicesTrustLevelsAction a)

ClientResult	updateClient (ClientModel m, SetTrustLevelNeededToSendKeysAction a)

ClientResult	updateClient (ClientModel m, PrepareForSharingRoomKeyAction a)

ClientResult	updateClient (ClientModel m, ImportFromKeyBackupFileAction a)

ClientResult	updateClient (ClientModel m, NotifyVerificationTrackerModelAction a)

ClientResult	updateClient (ClientModel m, RequestShareRoomSessionKeyAction a)

ClientResult	updateClient (ClientModel m, SetTypingAction a)

ClientResult	processResponse (ClientModel m, SetTypingResponse r)

ClientResult	updateClient (ClientModel m, PostReceiptAction a)

ClientResult	processResponse (ClientModel m, PostReceiptResponse r)

ClientResult	updateClient (ClientModel m, SetReadMarkerAction a)

ClientResult	processResponse (ClientModel m, SetReadMarkerResponse r)

ClientResult	updateClient (ClientModel m, CreateRoomAction a)

ClientResult	processResponse (ClientModel m, CreateRoomResponse r)

ClientResult	updateClient (ClientModel m, InviteToRoomAction a)

ClientResult	processResponse (ClientModel m, InviteUserResponse r)

ClientResult	updateClient (ClientModel m, JoinRoomAction a)

ClientResult	processResponse (ClientModel m, JoinRoomResponse r)

ClientResult	updateClient (ClientModel m, JoinRoomByIdAction a)

ClientResult	processResponse (ClientModel m, JoinRoomByIdResponse r)

ClientResult	updateClient (ClientModel m, LeaveRoomAction a)

ClientResult	processResponse (ClientModel m, LeaveRoomResponse r)

ClientResult	updateClient (ClientModel m, ForgetRoomAction a)

ClientResult	processResponse (ClientModel m, ForgetRoomResponse r)

ClientResult	updateClient (ClientModel m, KickAction a)

ClientResult	processResponse (ClientModel m, KickResponse r)

ClientResult	updateClient (ClientModel m, BanAction a)

ClientResult	processResponse (ClientModel m, BanResponse r)

ClientResult	updateClient (ClientModel m, UnbanAction a)

ClientResult	processResponse (ClientModel m, UnbanResponse r)

ClientResult	updateClient (ClientModel m, PaginateTimelineAction a)

ClientResult	processResponse (ClientModel m, GetRoomEventsResponse r)

ClientResult	updateClient (ClientModel m, GetUserProfileAction a)

ClientResult	processResponse (ClientModel m, GetUserProfileResponse r)

ClientResult	updateClient (ClientModel m, SetAvatarUrlAction a)

ClientResult	processResponse (ClientModel m, SetAvatarUrlResponse r)

ClientResult	updateClient (ClientModel m, SetDisplayNameAction a)

ClientResult	processResponse (ClientModel m, SetDisplayNameResponse r)

ClientResult	updateClient (ClientModel m, SendMessageAction a)

ClientResult	processResponse (ClientModel m, SendMessageResponse r)

ClientResult	updateClient (ClientModel m, SendToDeviceMessageAction a)

ClientResult	updateClient (ClientModel m, SendMultipleToDeviceMessagesAction a)

ClientResult	processResponse (ClientModel m, SendToDeviceResponse r)

ClientResult	updateClient (ClientModel m, SaveLocalEchoAction a)

ClientResult	updateClient (ClientModel m, UpdateLocalEchoStatusAction a)

ClientResult	updateClient (ClientModel m, RedactEventAction a)

ClientResult	processResponse (ClientModel m, RedactEventResponse r)

BaseJob	clientPerform (ClientModel m, GetRoomStatesAction a)

ClientResult	updateClient (ClientModel m, GetRoomStatesAction a)

ClientResult	processResponse (ClientModel m, GetRoomStateResponse r)

ClientResult	updateClient (ClientModel m, GetStateEventAction a)

ClientResult	processResponse (ClientModel m, GetRoomStateWithKeyResponse r)

ClientResult	updateClient (ClientModel m, SendStateEventAction a)

ClientResult	processResponse (ClientModel m, SetRoomStateWithKeyResponse r)

ClientResult	updateClient (ClientModel m, LoadEventsFromStorageAction a)

ClientResult	updateClient (ClientModel m, PurgeRoomTimelineAction a)

ClientResult	updateClient (ClientModel m, SyncAction)

ClientResult	processResponse (ClientModel m, SyncResponse r)

ClientResult	updateClient (ClientModel m, SetShouldSyncAction a)

ClientResult	updateClient (ClientModel m, PostInitialFiltersAction)

ClientResult	processResponse (ClientModel m, DefineFilterResponse r)

BaseJob	getRoomIdByAliasJob (ClientModel m, std::string roomAlias)

EffectStatus	parseGetRoomIdByAliasResponse (GetRoomIdByAliasResponse r)

template<class Archive >
void	serialize (Archive &ar, ClientModel &m, std::uint32_t const version)

std::string	increaseTxnId (std::string cur)

std::string	getTxnId (Event, ClientModel &m)

template<class K , class V , class List , class Func >
immer::map< K, V >	merge (immer::map< K, V > map, List list, Func keyOf)

std::string	keyOfPresence (Event e)

std::string	keyOfAccountData (Event e)

std::string	keyOfTimeline (Event e)

std::string	keyOfEphemeral (Event e)

template<class Archive >
void	serialize (Archive &ar, KeyOfState &m, std::uint32_t const)

KeyOfState	keyOfState (Event e)

template<class Context >
JobInterface &	getJobHandler (Context &&ctx)

template<class Context >
EventInterface &	getEventEmitter (Context &&ctx)

template<class ImmerT1 , class RangeT2 , class Pred , class Func >
ImmerT1	sortedUniqueMerge (ImmerT1 base, RangeT2 addon, Pred exists, Func keyOf)
	Merge `addon` into the sorted container `base`.

template<class Archive >
void	serialize (Archive &ar, DeviceKeyInfo &i, std::uint32_t const version)

template<class Archive >
void	serialize (Archive &ar, DeviceListTracker &t, std::uint32_t const)

std::string	percentEncode (std::string url)

	KAZV_DEFINE_COPYABLE_UNIQUE_PTR (PowerLevelsDesc, m_d)

std::vector< std::string >	splitPath (std::string path)

bool	matchGlob (std::string target, std::string pattern)

std::pair< bool, json >	validateRule (std::string ruleSetName, const json &rule)

Event	validatePushRules (const Event &e)

	KAZV_DEFINE_COPYABLE_UNIQUE_PTR (PushRulesDesc, m_d)

template<class Archive >
void	serialize (Archive &ar, LocalDraft &draft, std::uint32_t const)

PendingRoomKeyEvent	makePendingRoomKeyEventV0 (std::string txnId, Event event, immer::map< std::string, immer::flex_vector< std::string > > devices)

auto	sortKeyForTimelineEvent (Event e) -> std::tuple< Timestamp, std::string >
	Get the sort key for a timeline event.

auto	memberEventsByMembership (immer::map< KeyOfState, Event > stateEvents, const std::string &membership)

template<class Archive >
void	serialize (Archive &ar, ReadReceipt &r, std::uint32_t const)

template<class Archive >
void	serialize (Archive &ar, PendingRoomKeyEvent &e, std::uint32_t const version)

template<class Archive >
void	serialize (Archive &ar, RoomModel &r, std::uint32_t const version)

template<class Archive >
void	serialize (Archive &ar, RoomListModel &l, std::uint32_t const)

template<class Archive >
void	serialize (Archive &ar, SdkModel &s, std::uint32_t const)

template<class EventLoop , class Xform , class ... Enhancers>
auto	makeSdk (SdkModel sdk, JobInterface &jobHandler, EventInterface &eventEmitter, EventLoop &&eventLoop, Xform &&xform, Enhancers &&...enhancers) -> Sdk< EventLoop, Xform, Enhancers... >
	Create an sdk with the provided model.

std::size_t	makeDefaultSdkWithCryptoRandomSize ()

template<class EventLoop , class Xform , class ... Enhancers>
auto	makeDefaultEncryptedSdk (JobInterface &jobHandler, EventInterface &eventEmitter, EventLoop &&eventLoop, Xform &&xform, Enhancers &&...enhancers) -> Sdk< EventLoop, Xform, Enhancers... >

template<class PH , class Xform , class ... Enhancers>
auto	makeDefaultSdkWithCryptoRandom (RandomData random, JobInterface &jobHandler, EventInterface &eventEmitter, PH &&ph, Xform &&xform, Enhancers &&...enhancers) -> Sdk< PH, Xform, Enhancers... >
	Create an sdk with a default-constructed model, and a Crypto constructed with user-provided random data.

auto	withRandomGenerator (RandomInterface &random)
	An enhancer to use a custom random generator.

detail::ReturnEffectStatusT	failWithResponse (const BaseJob::Response &r)
	A effect that returns a failed EffectStatus upon invocation.

detail::ReturnEffectStatusT	failEffect (std::string errorCode, std::string errorMsg)
	An effect that returns a failed EffectStatus with the given error code and message.

std::string	encodeBase64 (std::string original, int flags=Base64Opts::none)
	Encodes the original string to base64.

std::string	decodeBase64 (std::string encoded, int flags=Base64Opts::none)
	Decode base64 string.

void	from_json (const nlohmann::json &j, KeyOfGroupSession &k)

void	to_json (nlohmann::json &j, const KeyOfGroupSession &k)

ByteArray	genRandom (int len)

RandomData	genRandomData (int len)

template<class Sess , class K >
immer::map< K, immer::box< Sess > >	sessionStdMapToImmer (std::unordered_map< K, Sess > &&stdMap)

void	to_json (nlohmann::json &j, const KeyOfDecryptedEvent &k)

void	from_json (const nlohmann::json &j, KeyOfDecryptedEvent &k)

void	to_json (nlohmann::json &j, const InboundGroupSession &s)

void	from_json (const nlohmann::json &j, InboundGroupSession &s)

template<class T >
std::string	toHex (T &&v)

std::pair< ByteArray, ByteArray >	deriveKeyExportKey (std::string password, ByteArray salt, std::size_t iterations)
	Derive the key-export key from the user-inputted password.

Maybe< nlohmann::json >	decryptKeyExport (std::string exportContent, std::string password)
	Decrypt the key-export file with the user-inputted password.

void	to_json (nlohmann::json &j, const OutboundGroupSession &s)

void	from_json (const nlohmann::json &j, OutboundGroupSession &s)

void	to_json (nlohmann::json &j, const Session &s)

void	from_json (const nlohmann::json &j, Session &s)

Timestamp	currentTimeMs ()

template<class Func >
void	withProcess (VerificationTracker &t, std::string userId, std::string deviceId, Func &&func)

template<class Exec >
	AsioPromiseHandler (Exec) -> AsioPromiseHandler< Exec >

EffectStatus	createDefaultForPromiseThen (EffectStatus)

EffectStatus	dataCombine (EffectStatus a, EffectStatus b)

EffectStatus	dataCombineNone (EffectStatus)

template<class Action , class Tag = lager::automatic_tag, class Model , class Reducer , class PH , class ... Enhancers>
auto	makeStore (Model &&initialModel, Reducer &&reducer, PH &&ph, Enhancers &&...enhancers)

Variables
detail::IntoImmerT	intoImmer {}

detail::ContainerMapT	containerMap {}

constexpr auto	eventContent

const detail::OutputConfig	kzo {}

const std::string	headFailureCancelledErrorCode {"MOE_KAZV_MXC_HEAD_FAILURE_CANCELLED"}

const std::string	headFailureCancelledErrorMsg {"This job is cancelled because one before it failed."}

const int	headFailureCancelledStatusCode {490}

template<class T >
constexpr auto	isPromise = std::is_base_of_v<TypelessPromise, T>

constexpr detail::DefaultValT	DEFVAL

const std::string	DEFTXNID {"0"}

const double	ROOM_TAG_DEFAULT_ORDER = 2

constexpr auto	simpleFail = detail::SimpleFailT{}
	A effect that returns a failed EffectStatus upon invocation.

const immer::map< std::string, std::string >	codeToMessage

template<class Reducer , class RetType , class Model , class Action , class Deps >
constexpr bool	hasEffect

Typedef Documentation

◆ Body

using Kazv::Body = typedef std::variant<EmptyBody, JsonBody, BytesBody, FileBody>

◆ BoolPromise

using Kazv::BoolPromise = typedef SingleTypePromise<bool>

◆ BoolPromiseInterface

using Kazv::BoolPromiseInterface = typedef SingleTypePromiseInterface<bool>

◆ ByteArray

using Kazv::ByteArray = typedef std::vector<unsigned char>

◆ Bytes

using Kazv::Bytes = typedef std::string

◆ BytesBody

using Kazv::BytesBody = typedef Bytes

◆ ClientAction

using Kazv::ClientAction = typedef std::variant< RoomListAction, LoginAction, TokenLoginAction, MLoginTokenLoginAction, LogoutAction, HardLogoutAction, GetWellknownAction, GetVersionsAction, SyncAction, SetShouldSyncAction, PostInitialFiltersAction, SetAccountDataAction, PaginateTimelineAction, SendMessageAction, SendStateEventAction, SaveLocalEchoAction, UpdateLocalEchoStatusAction, RedactEventAction, CreateRoomAction, GetRoomStatesAction, GetStateEventAction, InviteToRoomAction, JoinRoomByIdAction, JoinRoomAction, LeaveRoomAction, ForgetRoomAction, KickAction, BanAction, UnbanAction, SetAccountDataPerRoomAction, ProcessResponseAction, SetTypingAction, PostReceiptAction, SetReadMarkerAction, UploadContentAction, DownloadContentAction, DownloadThumbnailAction, SendToDeviceMessageAction, SendMultipleToDeviceMessagesAction, UploadIdentityKeysAction, GenerateAndUploadOneTimeKeysAction, QueryKeysAction, EnsureKeysFromDevicesAction, ClaimKeysAction, EncryptMegOlmEventAction, SetDeviceTrustLevelAction, SetDevicesTrustLevelsAction, SetTrustLevelNeededToSendKeysAction, PrepareForSharingRoomKeyAction, ImportFromKeyBackupFileAction, NotifyVerificationTrackerModelAction, RequestShareRoomSessionKeyAction, GetUserProfileAction, SetAvatarUrlAction, SetDisplayNameAction, ResubmitJobAction, LoadEventsFromStorageAction, PurgeRoomTimelineAction >

◆ ClientEffect

using Kazv::ClientEffect = typedef Effect<ClientAction, lager::deps<> >

◆ ClientResult

using Kazv::ClientResult = typedef std::pair<ClientModel, ClientEffect>

◆ Context

template<class A , class D = lager::deps<>>

using Kazv::Context = typedef ContextBase<DefaultRetType, A, D>

◆ DefaultRetType

using Kazv::DefaultRetType = typedef EffectStatus

◆ Effect

template<class A , class D = lager::deps<>>

using Kazv::Effect = typedef EffectBase<DefaultRetType, A, D>

◆ EventList

using Kazv::EventList = typedef immer::flex_vector<Event>

◆ FileBody

using Kazv::FileBody = typedef FileDesc

◆ FileContent

using Kazv::FileContent = typedef immer::flex_vector<char>

◆ Header

using Kazv::Header = typedef immer::box<std::map<std::string, std::string> >

◆ json

using Kazv::json = typedef nlohmann::json

◆ JsonBody

using Kazv::JsonBody = typedef JsonWrap

◆ KazvEvent

using Kazv::KazvEvent = typedef KazvTrigger

◆ KazvEventList

using Kazv::KazvEventList = typedef KazvTriggerList

◆ KazvTrigger

using Kazv::KazvTrigger = typedef std::variant< std::monostate, ReceivingPresenceEvent, ReceivingAccountDataEvent, ReceivingRoomTimelineEvent, ReceivingRoomStateEvent, RoomMembershipChanged, ReceivingRoomAccountDataEvent, ReceivingToDeviceMessage, LoginSuccessful, LoginFailed, SaveEventsRequested, VerificationTrackerModelChanged, UnrecognizedResponse >

◆ KazvTriggerList

using Kazv::KazvTriggerList = typedef immer::flex_vector<KazvTrigger>

◆ MaybeString

using Kazv::MaybeString = typedef Maybe<std::string>

◆ PowerLevel

using Kazv::PowerLevel = typedef std::int_fast64_t

◆ PromiseThenResult

template<class T , class P >

using Kazv::PromiseThenResult = typedef typename detail::PromiseThenResultT<T, P>::type

◆ RandomData

using Kazv::RandomData = typedef std::string

◆ RoomAction

using Kazv::RoomAction = typedef RoomModel::Action

◆ RoomListAction

using Kazv::RoomListAction = typedef RoomListModel::Action

◆ SdkAction

using Kazv::SdkAction = typedef std::variant< ClientAction >

◆ SdkEffect

using Kazv::SdkEffect = typedef Effect<SdkAction, lager::deps<JobInterface &, EventInterface &> >

◆ SdkModelCursorKey

using Kazv::SdkModelCursorKey = typedef lager::dep::key<SdkModelCursorTag, lager::dep::fn<std::shared_ptr<lager::reader<SdkModel> >> >

◆ SdkResult

using Kazv::SdkResult = typedef std::pair<SdkModel, SdkEffect>

◆ SessionList

using Kazv::SessionList = typedef std::vector<Session>

◆ Store

template<class Action , class Model , class Reducer , class Deps = lager::deps<>, class Tag = lager::automatic_tag>

using Kazv::Store = typedef StoreBase<Action, DefaultRetType, Model, Reducer, Deps, Tag>

◆ Timestamp

using Kazv::Timestamp = typedef std::int_fast64_t

◆ Variant

using Kazv::Variant = typedef std::variant<std::string, JsonWrap, Null>

◆ VerificationProcessState

Enumeration Type Documentation

◆ CastArrayStrategy

enum class Kazv::CastArrayStrategy

strong

Strategy used for castArray().

Enumerator
IgnoreInvalid	If any item is invalid, ignore them and add all valid entries into the output.
FailAll	If any item is invalid, fail the entire cast.

◆ CastObjectStrategy

enum class Kazv::CastObjectStrategy

strong

Strategy used for castObject().

Enumerator
IgnoreInvalid	If any item is invalid, ignore them and add all valid entries into the output.
FailAll	If any item is invalid, fail the entire cast.

◆ CreateRoomPreset

enum Kazv::CreateRoomPreset

Enumerator
PrivateChat
PublicChat
TrustedPrivateChat

◆ DeviceTrustLevel

enum Kazv::DeviceTrustLevel

Enumerator
Blocked
Unseen
Seen
Verified

◆ FileOpenMode

enum struct Kazv::FileOpenMode

strong

Enumerator
Read
Write

◆ FileOpRetCode

enum struct Kazv::FileOpRetCode

strong

Enumerator
Error
Success
Eof

◆ JobQueuePolicy

enum Kazv::JobQueuePolicy

Enumerator
AlwaysContinue
CancelFutureIfFailed

◆ RoomMembership

enum Kazv::RoomMembership

Enumerator
Invite
Join
Leave

◆ RoomVisibility

enum Kazv::RoomVisibility

Enumerator
Private
Public

◆ Status

enum Kazv::Status : bool

Enumerator
FAIL
SUCC

◆ ThumbnailResizingMethod

enum Kazv::ThumbnailResizingMethod

Enumerator
Crop
Scale

Function Documentation

◆ addPropertyMapToJson() [1/2]

void Kazv::addPropertyMapToJson	(	json &	j,
		const json &	arg
	)

inline

◆ addPropertyMapToJson() [2/2]

template<class MapT , std::enable_if_t<!std::is_same_v< std::decay_t< MapT >, json > &&!std::is_same_v< std::decay_t< MapT >, JsonWrap >, int > = 0>

void Kazv::addPropertyMapToJson	(	json &	j,
		MapT &&	arg
	)

inline

◆ addToJsonIfNeeded()

template<class T >

void Kazv::addToJsonIfNeeded	(	json &	j,
		std::string	name,
		T &&	arg
	)

inline

◆ addToQuery()

template<class T >

void Kazv::addToQuery	(	BaseJob::Query &	q,
		std::string	name,
		T &&	arg
	)

inline

◆ addToQueryIfNeeded()

template<class T >

void Kazv::addToQueryIfNeeded	(	BaseJob::Query &	q,
		std::string	name,
		T &&	arg
	)

inline

◆ allCursors() [1/2]

auto Kazv::allCursors ( )

inline

◆ allCursors() [2/2]

template<class Cursor , class ... Cursors>

constexpr auto Kazv::allCursors	(	Cursor &&	first,
		Cursors &&...	cursors
	)

constexpr

◆ anyCursor() [1/2]

auto Kazv::anyCursor ( )

inline

◆ anyCursor() [2/2]

template<class Cursor , class ... Cursors>

constexpr auto Kazv::anyCursor	(	Cursor &&	first,
		Cursors &&...	cursors
	)

constexpr

◆ AsioPromiseHandler()

template<class Exec >

Kazv::AsioPromiseHandler ( Exec ) -> AsioPromiseHandler< Exec >

◆ AsioStdFileHandler()

template<class Exec >

Kazv::AsioStdFileHandler ( Exec ) -> AsioStdFileHandler< Exec >

◆ cast()

template<class Jsonish , class Key , class Validator >

bool Kazv::cast	(	Jsonish &	ret,
		const Jsonish &	input,
		Key &&	k,
		Validator &&	f
	)

Run validator against input[k] and add it to ret.

A validator is a function taking a Jsonish value and return a pair of boolean (the status) and a Jsonish value (the output).

If the status is true, the output will be added to ret[k]. If the status is false, the output will be ignored.

Example:

json j = json::object();
Kazv::cast(
    j,
    json{{"foo", "1"}},
    "foo",
    [](const json &v) -> std::pair<bool, json> {
        return v.is_string()
            ? {true, v.template get<std::string>() + "x"}
            : {false, v};
    }
); // true, j = {{"foo", "1x"}}};
 
json j2 = json::object();
Kazv::cast(
    j,
    json{{"foo", 1}},
    "foo",
    [](const json &v) -> std::pair<bool, json> {
        return v.is_string()
            ? {true, v.template get<std::string>() + "x"}
            : {false, v};
    }
); // true, j2 = json::object();

Parameters

input	The original json taken from user input.
k	The key (usually a property name of a json object) to process on.
f	The validator.
ret	The read-write reference of the returning json.

Returns: Whether the cast is successful. The cast is successful if and only if the validator returns a status of true.

◆ castArray()

template<class Jsonish , class Key , class Validator >

bool Kazv::castArray	(	Jsonish &	ret,
		const Jsonish &	input,
		Key &&	k,
		Validator &&	f,
		CastArrayStrategy	strategy
	)

Cast an array of items.

Run the validator on each item of input[k] and accumulate the result into ret.

Example:

json j = json::object();
Kazv::castArray(
    j,
    json{{"foo", {"1", "2", "3", 4}}},
    "foo",
    [](const json &v) -> std::pair<bool, json> {
        return v.is_string()
            ? {true, v.template get<std::string>() + "x"}
            : {false, v};
    },
    Kazv::CastArrayStrategy::IgnoreInvalid
); // true, j = {{"foo", {"1x", "2x", "3x"}}};
 
json j2 = json::object();
Kazv::castArray(
    j2,
    json{{"foo", {"1", "2", "3", 4}}},
    "foo",
    [](const json &v) -> std::pair<bool, json> {
        return v.is_string()
            ? {true, v.template get<std::string>() + "x"}
            : {false, v};
    },
    Kazv::CastArrayStrategy::FailAll
); // false, j2 = json::object();

Parameters

input	The original json taken from user input.
k	The key (usually a property name of a json object) to process on.
f	The validator.
ret	The read-write reference of the returning json.
strategy	The strategy to use when handling invalid items. `CastArrayStrategy::IgnoreInvalid` makes the cast always successful (providing `input[k]` is an array), and all valid items will be added to `ret`. `CastArrayStrategy::FailAll` makes the cast successful only when all input items can be casted.

Returns: Whether the cast is successful. If input[k] is not an array, it be unsuccessful.

◆ castObject()

template<class Jsonish , class Key , class Validator >

bool Kazv::castObject	(	Jsonish &	ret,
		const Jsonish &	input,
		Key &&	k,
		Validator &&	f,
		CastObjectStrategy	strategy
	)

Cast an object of items.

Run the validator on each key-value pair (as a json array) of input[k] and accumulate the result into ret.

Example:

json j = json::object();
Kazv::castObject(
    j,
    json{{"foo", {{"1", "2"}, {"3", 4}}}},
    "foo",
    [](const json &kv) -> std::pair<bool, json> {
        const key = kv[0];
        const value = kv[1];
        return value.is_string()
            ? {true, json::array({key, v.template get<std::string>() + "x"})}
            : {false, v};
    },
    Kazv::CastObjectStrategy::IgnoreInvalid
); // true, j = {{"foo", {{"1", "2x"}}}};
 
json j2 = json::object();
Kazv::castObject(
    j2,
    json{{"foo", {{"1", "2"}, {"3", 4}}}},
    "foo",
    [](const json &v) -> std::pair<bool, json> {
        const key = kv[0];
        const value = kv[1];
        return value.is_string()
            ? {true, json::array({key, v.template get<std::string>() + "x"})}
            : {false, v};
    },
    Kazv::CastObjectStrategy::FailAll
); // false, j2 = json::object();

Parameters

input	The original json taken from user input.
k	The key (usually a property name of a json object) to process on.
f	The validator.
ret	The read-write reference of the returning json.
strategy	The strategy to use when handling invalid items. `CastObjectStrategy::IgnoreInvalid` makes the cast always successful (providing `input[k]` is an object), and all valid items will be added to `ret`. `CastObjectStrategy::FailAll` makes the cast successful only when all input items can be casted.

Returns: Whether the cast is successful. If input[k] is not an object, it be unsuccessful.

◆ clientPerform() [1/2]

BaseJob Kazv::clientPerform	(	ClientModel	m,
		GetRoomStatesAction	a
	)

◆ clientPerform() [2/2]

std::optional< BaseJob > Kazv::clientPerform	(	ClientModel	m,
		QueryKeysAction	a
	)

◆ createDefaultForPromiseThen()

EffectStatus Kazv::createDefaultForPromiseThen ( EffectStatus )

inline

◆ currentTimeMs()

Timestamp Kazv::currentTimeMs ( )

inline

◆ dataCombine()

EffectStatus Kazv::dataCombine	(	EffectStatus	a,
		EffectStatus	b
	)

inline

◆ dataCombineNone()

EffectStatus Kazv::dataCombineNone ( EffectStatus )

inline

◆ decodeBase64()

std::string Kazv::decodeBase64	(	std::string	encoded,
		int	flags = `Base64Opts::none`
	)

Decode base64 string.

Parameters

encoded	The base64-encoded string.
flags	Options for the decoder. See Base64Opts.

◆ decryptEvent()

Event Kazv::decryptEvent	(	ClientModel &	m,
		Event	e
	)

◆ decryptKeyExport()

Maybe< nlohmann::json > Kazv::decryptKeyExport	(	std::string	exportContent,
		std::string	password
	)

Decrypt the key-export file with the user-inputted password.

Parameters

exportContent	The file content.
password	The password inputted by the user.

Returns: A Maybe containing the json of the keys contained in the file, if the operation is successful. Otherwise, it contains the error code defined in the namespace Kazv::DecryptKeyExportErrorCodes.

◆ deriveKeyExportKey()

std::pair< ByteArray, ByteArray > Kazv::deriveKeyExportKey	(	std::string	password,
		ByteArray	salt,
		std::size_t	iterations
	)

Derive the key-export key from the user-inputted password.

Parameters

password	The user-inputted password.
salt	The salt from the key export file, or randomly generated when exporting.
iterations	The number of iterations from the key export file, or manually specified when exporting.

Returns: A pair of [K, K'] specified in the Key Export section in the matrix spec: https://spec.matrix.org/v1.15/client-server-api/#key-export-format.

◆ encodeBase64()

std::string Kazv::encodeBase64	(	std::string	original,
		int	flags = `Base64Opts::none`
	)

Encodes the original string to base64.

Parameters

original	The original string to encode.
flags	Options for the encoder. See Base64Opts.

◆ failEffect()

detail::ReturnEffectStatusT Kazv::failEffect	(	std::string	errorCode,
		std::string	errorMsg
	)

An effect that returns a failed EffectStatus with the given error code and message.

◆ failWithResponse()

detail::ReturnEffectStatusT Kazv::failWithResponse ( const BaseJob::Response & r )

A effect that returns a failed EffectStatus upon invocation.

◆ from_json() [1/5]

void Kazv::from_json	(	const nlohmann::json &	j,
		InboundGroupSession &	s
	)

◆ from_json() [2/5]

void Kazv::from_json	(	const nlohmann::json &	j,
		KeyOfDecryptedEvent &	k
	)

inline

◆ from_json() [3/5]

void Kazv::from_json	(	const nlohmann::json &	j,
		KeyOfGroupSession &	k
	)

inline

◆ from_json() [4/5]

void Kazv::from_json	(	const nlohmann::json &	j,
		OutboundGroupSession &	s
	)

◆ from_json() [5/5]

void Kazv::from_json	(	const nlohmann::json &	j,
		Session &	s
	)

◆ genRandom()

ByteArray Kazv::genRandom ( int len )

inline

◆ genRandomData()

RandomData Kazv::genRandomData ( int len )

inline

◆ getEventEmitter()

template<class Context >

EventInterface & Kazv::getEventEmitter ( Context && ctx )

◆ getIn() [1/2]

template<class ImmerT , class K , class ... Keys>

auto Kazv::getIn	(	ImmerT &&	container,
		K &&	key,
		Keys &&...	keys
	)

◆ getIn() [2/2]

template<class T >

auto Kazv::getIn ( T && item )

◆ getInJson()

template<class Jsonish , class RangeT >

std::optional< std::decay_t< Jsonish > > Kazv::getInJson	(	Jsonish &&	j,
		RangeT &&	path,
		std::size_t	index = `0`
	)

◆ getJobHandler()

template<class Context >

JobInterface & Kazv::getJobHandler ( Context && ctx )

◆ getRoomIdByAliasJob()

BaseJob Kazv::getRoomIdByAliasJob	(	ClientModel	m,
		std::string	roomAlias
	)

◆ getTxnId()

std::string Kazv::getTxnId	(	Event	,
		ClientModel &	m
	)

◆ hasAtThat()

template<class Jsonish , class Key , class Func >

bool Kazv::hasAtThat	(	Jsonish &&	j,
		Key &&	k,
		Func &&	f
	)

◆ identValidate()

template<class Func >

auto Kazv::identValidate ( Func && f )

Make an identity validator.

The returned validator runs a predicate f against a value val. If the return value is true, return a pair of true and val. Otherwise, return a pair of false and val.

Parameters

f	The predicate that judges the validity of a value.

Returns: A validator.

◆ increaseTxnId()

std::string Kazv::increaseTxnId ( std::string cur )

◆ isBodyJson()

bool Kazv::isBodyJson ( Body body )

inline

◆ isNonCompoundCanonicalJsonValue()

bool Kazv::isNonCompoundCanonicalJsonValue ( const nlohmann::json & j )

inline

◆ jsonAtOr()

template<class T , class V >

constexpr auto Kazv::jsonAtOr	(	T &&	key,
		V &&	defaultValue
	)

constexpr

◆ KAZV_DEFINE_COPYABLE_UNIQUE_PTR() [1/2]

Kazv::KAZV_DEFINE_COPYABLE_UNIQUE_PTR	(	PowerLevelsDesc	,
		m_d
	)

◆ KAZV_DEFINE_COPYABLE_UNIQUE_PTR() [2/2]

Kazv::KAZV_DEFINE_COPYABLE_UNIQUE_PTR	(	PushRulesDesc	,
		m_d
	)

◆ keyOfAccountData()

std::string Kazv::keyOfAccountData ( Event e )

inline

◆ keyOfEphemeral()

std::string Kazv::keyOfEphemeral ( Event e )

inline

◆ keyOfPresence()

std::string Kazv::keyOfPresence ( Event e )

inline

◆ keyOfState()

KeyOfState Kazv::keyOfState ( Event e )

inline

◆ keyOfTimeline()

std::string Kazv::keyOfTimeline ( Event e )

inline

◆ makeDefaultEncryptedSdk()

template<class EventLoop , class Xform , class ... Enhancers>

auto Kazv::makeDefaultEncryptedSdk	(	JobInterface &	jobHandler,
		EventInterface &	eventEmitter,
		EventLoop &&	eventLoop,
		Xform &&	xform,
		Enhancers &&...	enhancers
	)		-> Sdk<EventLoop, Xform, Enhancers...>

inline

◆ makeDefaultSdkWithCryptoRandom()

template<class PH , class Xform , class ... Enhancers>

auto Kazv::makeDefaultSdkWithCryptoRandom	(	RandomData	random,
		JobInterface &	jobHandler,
		EventInterface &	eventEmitter,
		PH &&	ph,
		Xform &&	xform,
		Enhancers &&...	enhancers
	)		-> Sdk<PH, Xform, Enhancers...>

inline

Create an sdk with a default-constructed model, and a Crypto constructed with user-provided random data.

Parameters

random	The random data to construct Crypto. Must be of at least size `makeDefaultSdkWithCryptoRandomSize()`.
jobHandler	The job handler for the sdk.
eventEmitter	The event emitter for the sdk.
ph	The Promise handler for the sdk.
xform	A function to extract the SdkModel from the model type of the created Store. This is to take into account any enhancer that changes the model type. If you do not use any enhancer that changes the model type, put an identity function (e.g. `zug::identity`) here.
enhancers	The enhancers to pass to `makeStore()`.

Returns: An Sdk created with these parameters.

See also: JobInterface, EventInterface, PromiseInterface

◆ makeDefaultSdkWithCryptoRandomSize()

std::size_t Kazv::makeDefaultSdkWithCryptoRandomSize ( )

inline

Returns: The size of random data needed for makeDefaultSdkWithCryptoRandom

◆ makeDefaultValue()

template<class Jsonish , class Key , class Jsonish2 >

std::decay_t< Jsonish > Kazv::makeDefaultValue	(	Jsonish &&	input,
		Key &&	k,
		Jsonish2 &&	defaultValue
	)

Replace a non-existent value with a default one.

If input contains k, return input as-is. Otherwise return input but with [k] replaced with defaultValue.

Parameters

input	The input value.
k	The key to process on.
defaultValue	The default value to replace with.

Returns: input if input contains k, otherwise, input where [k] is replaced with defaultValue.

◆ makePendingRoomKeyEventV0()

PendingRoomKeyEvent Kazv::makePendingRoomKeyEventV0	(	std::string	txnId,
		Event	event,
		immer::map< std::string, immer::flex_vector< std::string > >	devices
	)

◆ makeSdk()

template<class EventLoop , class Xform , class ... Enhancers>

auto Kazv::makeSdk	(	SdkModel	sdk,
		JobInterface &	jobHandler,
		EventInterface &	eventEmitter,
		EventLoop &&	eventLoop,
		Xform &&	xform,
		Enhancers &&...	enhancers
	)		-> Sdk<EventLoop, Xform, Enhancers...>

inline

Create an sdk with the provided model.

Parameters

sdk	The initial SdkModel.
jobHandler	The job handler for the sdk.
eventEmitter	The event emitter for the sdk.
ph	The Promise handler for the sdk.
xform	A function to extract the SdkModel from the model type of the created Store. This is to take into account any enhancer that changes the model type. If you do not use any enhancer that changes the model type, put an identity function (e.g. `zug::identity`) here.
enhancers	The enhancers to pass to `makeStore()`.

Returns: An Sdk created with these parameters.

See also: JobInterface, EventInterface, PromiseInterface

◆ makeStore()

template<class Action , class Tag = lager::automatic_tag, class Model , class Reducer , class PH , class ... Enhancers>

auto Kazv::makeStore	(	Model &&	initialModel,
		Reducer &&	reducer,
		PH &&	ph,
		Enhancers &&...	enhancers
	)

◆ matchGlob()

bool Kazv::matchGlob	(	std::string	target,
		std::string	pattern
	)

◆ memberEventsByMembership()

auto Kazv::memberEventsByMembership	(	immer::map< KeyOfState, Event >	stateEvents,
		const std::string &	membership
	)

◆ merge()

template<class K , class V , class List , class Func >

immer::map< K, V > Kazv::merge	(	immer::map< K, V >	map,
		List	list,
		Func	keyOf
	)

◆ mxcUriToMediaDesc()

std::pair< std::string, std::string > Kazv::mxcUriToMediaDesc ( std::string mxcUri )

◆ operator!=()

bool Kazv::operator!=	(	const BaseJob &	a,
		const BaseJob &	b
	)

◆ operator==() [1/2]

bool Kazv::operator==	(	const BaseJob &	a,
		const BaseJob &	b
	)

◆ operator==() [2/2]

bool Kazv::operator==	(	const Event &	a,
		const Event &	b
	)

◆ parseGetRoomIdByAliasResponse()

EffectStatus Kazv::parseGetRoomIdByAliasResponse ( GetRoomIdByAliasResponse r )

◆ percentEncode()

std::string Kazv::percentEncode ( std::string url )

◆ processResponse() [1/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		BanResponse	r
	)

◆ processResponse() [2/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		ClaimKeysResponse	r
	)

◆ processResponse() [3/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		CreateRoomResponse	r
	)

◆ processResponse() [4/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		DefineFilterResponse	r
	)

◆ processResponse() [5/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		ForgetRoomResponse	r
	)

◆ processResponse() [6/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		GetContentResponse	r
	)

◆ processResponse() [7/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		GetContentThumbnailResponse	r
	)

◆ processResponse() [8/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		GetRoomEventsResponse	r
	)

◆ processResponse() [9/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		GetRoomStateResponse	r
	)

◆ processResponse() [10/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		GetRoomStateWithKeyResponse	r
	)

◆ processResponse() [11/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		GetUserProfileResponse	r
	)

◆ processResponse() [12/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		GetVersionsResponse	r
	)

◆ processResponse() [13/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		GetWellknownResponse	r
	)

◆ processResponse() [14/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		InviteUserResponse	r
	)

◆ processResponse() [15/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		JoinRoomByIdResponse	r
	)

◆ processResponse() [16/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		JoinRoomResponse	r
	)

◆ processResponse() [17/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		KickResponse	r
	)

◆ processResponse() [18/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		LeaveRoomResponse	r
	)

◆ processResponse() [19/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		LoginResponse	r
	)

◆ processResponse() [20/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		LogoutResponse	r
	)

◆ processResponse() [21/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		PostReceiptResponse	r
	)

◆ processResponse() [22/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		QueryKeysResponse	r
	)

◆ processResponse() [23/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		RedactEventResponse	r
	)

◆ processResponse() [24/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		SendMessageResponse	r
	)

◆ processResponse() [25/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		SendToDeviceResponse	r
	)

◆ processResponse() [26/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		SetAccountDataPerRoomResponse	r
	)

◆ processResponse() [27/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		SetAccountDataResponse	r
	)

◆ processResponse() [28/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		SetAvatarUrlResponse	r
	)

◆ processResponse() [29/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		SetDisplayNameResponse	r
	)

◆ processResponse() [30/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		SetReadMarkerResponse	r
	)

◆ processResponse() [31/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		SetRoomStateWithKeyResponse	r
	)

◆ processResponse() [32/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		SetTypingResponse	r
	)

◆ processResponse() [33/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		SyncResponse	r
	)

◆ processResponse() [34/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		UnbanResponse	r
	)

◆ processResponse() [35/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		UploadContentResponse	r
	)

◆ processResponse() [36/36]

ClientResult Kazv::processResponse	(	ClientModel	m,
		UploadKeysResponse	r
	)

◆ serialize() [1/10]

template<class Archive >

void Kazv::serialize	(	Archive &	ar,
		ClientModel &	m,
		std::uint32_t const	version
	)

◆ serialize() [2/10]

template<class Archive >

void Kazv::serialize	(	Archive &	ar,
		DeviceKeyInfo &	i,
		std::uint32_t const	version
	)

◆ serialize() [3/10]

template<class Archive >

void Kazv::serialize	(	Archive &	ar,
		DeviceListTracker &	t,
		std::uint32_t const
	)

◆ serialize() [4/10]

template<class Archive >

void Kazv::serialize	(	Archive &	ar,
		KeyOfState &	m,
		std::uint32_t const
	)

◆ serialize() [5/10]

template<class Archive >

void Kazv::serialize	(	Archive &	ar,
		LocalDraft &	draft,
		std::uint32_t const
	)

◆ serialize() [6/10]

template<class Archive >

void Kazv::serialize	(	Archive &	ar,
		PendingRoomKeyEvent &	e,
		std::uint32_t const	version
	)

◆ serialize() [7/10]

template<class Archive >

void Kazv::serialize	(	Archive &	ar,
		ReadReceipt &	r,
		std::uint32_t const
	)

◆ serialize() [8/10]

template<class Archive >

void Kazv::serialize	(	Archive &	ar,
		RoomListModel &	l,
		std::uint32_t const
	)

◆ serialize() [9/10]

template<class Archive >

void Kazv::serialize	(	Archive &	ar,
		RoomModel &	r,
		std::uint32_t const	version
	)

◆ serialize() [10/10]

template<class Archive >

void Kazv::serialize	(	Archive &	ar,
		SdkModel &	s,
		std::uint32_t const
	)

◆ sessionStdMapToImmer()

template<class Sess , class K >

immer::map< K, immer::box< Sess > > Kazv::sessionStdMapToImmer ( std::unordered_map< K, Sess > && stdMap )

◆ setIn() [1/3]

template<class ImmerT , class K >

auto Kazv::setIn	(	ImmerT	container,
		std::decay_t< decltype(getIn(std::declval< ImmerT >(), std::declval< K >()))>	newVal,
		K &&	key
	)		-> std::decay_t<ImmerT>

◆ setIn() [2/3]

template<class ImmerT , class K , class ... Keys>

auto Kazv::setIn	(	ImmerT	container,
		std::decay_t< decltype(getIn(std::declval< ImmerT >(), std::declval< K >(), std::declval< Keys >()...))>	newVal,
		K &&	key,
		Keys &&...	keys
	)		-> std::decay_t<ImmerT>

◆ setIn() [3/3]

template<class T >

auto Kazv::setIn	(	T	,
		T	newVal
	)

◆ sortedUniqueMerge()

template<class ImmerT1 , class RangeT2 , class Pred , class Func >

ImmerT1 Kazv::sortedUniqueMerge	(	ImmerT1	base,
		RangeT2	addon,
		Pred	exists,
		Func	keyOf
	)

Merge addon into the sorted container base.

This function will look into every item x in addon. If exists(x), nothing is done. Otherwise, it does a binary search in base. If there is an item k where keyOf(k) == keyOf(x), nothing is done. Otherwise, x is inserted into base, keeping the sort order.

This function invokes at most O(|addon|*log(|base|)) comparisons; each comparison invokes exactly 2 keyOfs.

This function invokes at most |addon| insertions of base.

This function invokes exists exactly |addon| times.

Parameters

base	An immer sequence container of some type T. `base` must be sorted in strict ascending order in terms of `keyOf`. I.e., For any two items x, y: `keyOf(x) < keyOf(y)` iff x is before y.
addon	A range of the same type T.
exists	A function taking T and producing a boolean value.
keyOf	A key function for the sorting of `base`. It must be a strong order.

◆ sortKeyForTimelineEvent()

auto Kazv::sortKeyForTimelineEvent ( Event e ) -> std::tuple< Timestamp, std::string >

Get the sort key for a timeline event.

If the key is larger, the event should be placed at the more recent end of the timeline.

Parameters

e	The event to get the sort key for.

Returns: The sort key. You MUST use auto to store the result.

◆ splitPath()

std::vector< std::string > Kazv::splitPath ( std::string path )

◆ to_json() [1/5]

void Kazv::to_json	(	nlohmann::json &	j,
		const InboundGroupSession &	s
	)

◆ to_json() [2/5]

void Kazv::to_json	(	nlohmann::json &	j,
		const KeyOfDecryptedEvent &	k
	)

inline

◆ to_json() [3/5]

void Kazv::to_json	(	nlohmann::json &	j,
		const KeyOfGroupSession &	k
	)

inline

◆ to_json() [4/5]

void Kazv::to_json	(	nlohmann::json &	j,
		const OutboundGroupSession &	s
	)

◆ to_json() [5/5]

void Kazv::to_json	(	nlohmann::json &	j,
		const Session &	s
	)

◆ toHex()

template<class T >

std::string Kazv::toHex ( T && v )

◆ tryDecryptEvents()

ClientModel Kazv::tryDecryptEvents ( ClientModel m )

◆ updateClient() [1/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		BanAction	a
	)

◆ updateClient() [2/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		ClaimKeysAction	a
	)

◆ updateClient() [3/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		CreateRoomAction	a
	)

◆ updateClient() [4/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		DownloadContentAction	a
	)

◆ updateClient() [5/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		DownloadThumbnailAction	a
	)

◆ updateClient() [6/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		EncryptMegOlmEventAction	a
	)

◆ updateClient() [7/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		EnsureKeysFromDevicesAction	a
	)

◆ updateClient() [8/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		ForgetRoomAction	a
	)

◆ updateClient() [9/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		GenerateAndUploadOneTimeKeysAction	a
	)

◆ updateClient() [10/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		GetRoomStatesAction	a
	)

◆ updateClient() [11/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		GetStateEventAction	a
	)

◆ updateClient() [12/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		GetUserProfileAction	a
	)

◆ updateClient() [13/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		GetVersionsAction	a
	)

◆ updateClient() [14/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		GetWellknownAction	a
	)

◆ updateClient() [15/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		HardLogoutAction
	)

◆ updateClient() [16/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		ImportFromKeyBackupFileAction	a
	)

◆ updateClient() [17/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		InviteToRoomAction	a
	)

◆ updateClient() [18/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		JoinRoomAction	a
	)

HACK: wait for real boost::url

◆ updateClient() [19/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		JoinRoomByIdAction	a
	)

◆ updateClient() [20/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		KickAction	a
	)

◆ updateClient() [21/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		LeaveRoomAction	a
	)

◆ updateClient() [22/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		LoadEventsFromStorageAction	a
	)

◆ updateClient() [23/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		LoginAction	a
	)

◆ updateClient() [24/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		LogoutAction
	)

◆ updateClient() [25/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		MLoginTokenLoginAction	a
	)

◆ updateClient() [26/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		NotifyVerificationTrackerModelAction	a
	)

◆ updateClient() [27/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		PaginateTimelineAction	a
	)

◆ updateClient() [28/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		PostInitialFiltersAction
	)

◆ updateClient() [29/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		PostReceiptAction	a
	)

◆ updateClient() [30/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		PrepareForSharingRoomKeyAction	a
	)

◆ updateClient() [31/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		PurgeRoomTimelineAction	a
	)

◆ updateClient() [32/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		QueryKeysAction	a
	)

◆ updateClient() [33/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		RedactEventAction	a
	)

◆ updateClient() [34/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		RequestShareRoomSessionKeyAction	a
	)

◆ updateClient() [35/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SaveLocalEchoAction	a
	)

◆ updateClient() [36/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SendMessageAction	a
	)

◆ updateClient() [37/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SendMultipleToDeviceMessagesAction	a
	)

◆ updateClient() [38/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SendStateEventAction	a
	)

◆ updateClient() [39/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SendToDeviceMessageAction	a
	)

◆ updateClient() [40/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SetAccountDataAction	a
	)

◆ updateClient() [41/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SetAccountDataPerRoomAction	a
	)

◆ updateClient() [42/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SetAvatarUrlAction	a
	)

◆ updateClient() [43/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SetDevicesTrustLevelsAction	a
	)

◆ updateClient() [44/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SetDeviceTrustLevelAction	a
	)

◆ updateClient() [45/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SetDisplayNameAction	a
	)

◆ updateClient() [46/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SetReadMarkerAction	a
	)

◆ updateClient() [47/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SetShouldSyncAction	a
	)

◆ updateClient() [48/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SetTrustLevelNeededToSendKeysAction	a
	)

◆ updateClient() [49/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SetTypingAction	a
	)

◆ updateClient() [50/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		SyncAction
	)

◆ updateClient() [51/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		TokenLoginAction	a
	)

◆ updateClient() [52/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		UnbanAction	a
	)

◆ updateClient() [53/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		UpdateLocalEchoStatusAction	a
	)

◆ updateClient() [54/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		UploadContentAction	a
	)

◆ updateClient() [55/55]

ClientResult Kazv::updateClient	(	ClientModel	m,
		UploadIdentityKeysAction
	)

◆ updateIn() [1/2]

template<class ImmerT , class Func , class ... Keys>

auto Kazv::updateIn	(	ImmerT	container,
		Func	func,
		Keys &&...	keys
	)		-> ImmerT

◆ updateIn() [2/2]

template<class T , class Func >

auto Kazv::updateIn	(	T	oldVal,
		Func	func
	)		-> T

◆ validatePushRules()

Event Kazv::validatePushRules ( const Event & e )

◆ validateRule()

std::pair< bool, json > Kazv::validateRule	(	std::string	ruleSetName,
		const json &	rule
	)

◆ withBox()

template<class ImmerT , class Func , class ValueT = typename ImmerT::value_type>

auto Kazv::withBox	(	ImmerT &	box,
		Func &&	func
	)		-> std::decay_t<std::invoke_result_t<Func &&, ValueT &>>

Do something with the box, updating its value, then return the return value of the function.

Parameters

box	The immer::box<T>.
func	A function taking T& as an argument. It is expected to modify its argument in-place.

Returns: void if func returns void. func(T&) otherwise. If box holds a unique value, no copy of T is called.

◆ withMapBox()

template<class ImmerT , class Key , class Func , class BoxT = typename ImmerT::mapped_type, class ValueT = typename BoxT::value_type>

auto Kazv::withMapBox	(	ImmerT &	map,
		Key &&	k,
		Func &&	func
	)		-> std::decay_t<std::invoke_result_t<Func &&, ValueT &>>

◆ withProcess()

template<class Func >

void Kazv::withProcess	(	VerificationTracker &	t,
		std::string	userId,
		std::string	deviceId,
		Func &&	func
	)

◆ withRandomGenerator()

auto Kazv::withRandomGenerator ( RandomInterface & random )

inline

An enhancer to use a custom random generator.

This is to be used with makeSdk()-series functions.

Parameters

random The random generator to use.

Variable Documentation

◆ codeToMessage

const immer::map<std::string, std::string> Kazv::codeToMessage

inline

Initial value:

= {
        {VCC::unexpectedMessage, "Unexpected message"},
        {VCC::userCancel, "User cancelled"},
        {VCC::keyMismatch, "Key mismatch"},
        {VCC::timeout, "Timeout"},
        {VCC::unknownMethod, "Unknown method"},
        {VCC::invalidMessage, "Invalid message"},
        {VCC::acceptedElsewhere, "Accepted elsewhere"},
        {VCC::mismatchedCommitment, "Mismatched commitment hash"},
        {VCC::mismatchedSas, "Mismatched SAS"},
    }

◆ containerMap

detail::ContainerMapT Kazv::containerMap {}

inline

◆ DEFTXNID

const std::string Kazv::DEFTXNID {"0"}

inline

◆ DEFVAL

constexpr detail::DefaultValT Kazv::DEFVAL

constexpr

◆ eventContent

constexpr auto Kazv::eventContent

inlineconstexpr

Initial value:

=
        zug::map([](auto &&event) {
                     return std::forward<decltype(event)>(event).content();
                 })

◆ hasEffect

template<class Reducer , class RetType , class Model , class Action , class Deps >

constexpr bool Kazv::hasEffect

constexpr

Initial value:

= boost::hana::is_valid(
        []() -> decltype((void)EffectBase<RetType, Action, Deps>(
                             std::get<1>(std::declval<std::invoke_result_t<Reducer, Model, Action>>()))) {}
        )()

◆ headFailureCancelledErrorCode

const std::string Kazv::headFailureCancelledErrorCode {"MOE_KAZV_MXC_HEAD_FAILURE_CANCELLED"}

inline

◆ headFailureCancelledErrorMsg

const std::string Kazv::headFailureCancelledErrorMsg {"This job is cancelled because one before it failed."}

inline

◆ headFailureCancelledStatusCode

const int Kazv::headFailureCancelledStatusCode {490}

inline

◆ intoImmer

detail::IntoImmerT Kazv::intoImmer {}

inline

◆ isPromise

template<class T >

constexpr auto Kazv::isPromise = std::is_base_of_v<TypelessPromise, T>

constexpr

◆ kzo

const detail::OutputConfig Kazv::kzo {}

◆ ROOM_TAG_DEFAULT_ORDER

const double Kazv::ROOM_TAG_DEFAULT_ORDER = 2

inline

◆ simpleFail

constexpr auto Kazv::simpleFail = detail::SimpleFailT{}

constexpr

A effect that returns a failed EffectStatus upon invocation.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ Body

◆ BoolPromise

◆ BoolPromiseInterface

◆ ByteArray

◆ Bytes

◆ BytesBody

◆ ClientAction

◆ ClientEffect

◆ ClientResult

◆ Context

◆ DefaultRetType

◆ Effect

◆ EventList

◆ FileBody

◆ FileContent

◆ Header

◆ json

◆ JsonBody

◆ KazvEvent

◆ KazvEventList

◆ KazvTrigger

◆ KazvTriggerList

◆ MaybeString

◆ PowerLevel

◆ PromiseThenResult

◆ RandomData

◆ RoomAction

◆ RoomListAction

◆ SdkAction

◆ SdkEffect

◆ SdkModelCursorKey

◆ SdkResult

◆ SessionList

◆ Store

◆ Timestamp

◆ Variant

◆ VerificationProcessState

Enumeration Type Documentation

◆ CastArrayStrategy

◆ CastObjectStrategy

◆ CreateRoomPreset

◆ DeviceTrustLevel

◆ FileOpenMode

◆ FileOpRetCode

◆ JobQueuePolicy

◆ RoomMembership

◆ RoomVisibility

◆ Status

◆ ThumbnailResizingMethod

Function Documentation

◆ addPropertyMapToJson() [1/2]

◆ addPropertyMapToJson() [2/2]

◆ addToJsonIfNeeded()

◆ addToQuery()

◆ addToQueryIfNeeded()

◆ allCursors() [1/2]

◆ allCursors() [2/2]

◆ anyCursor() [1/2]

◆ anyCursor() [2/2]

◆ AsioPromiseHandler()

◆ AsioStdFileHandler()

◆ cast()

◆ castArray()

◆ castObject()

◆ clientPerform() [1/2]

◆ clientPerform() [2/2]

◆ createDefaultForPromiseThen()

◆ currentTimeMs()

◆ dataCombine()

◆ dataCombineNone()

◆ decodeBase64()

◆ decryptEvent()

◆ decryptKeyExport()