No OneTemporary
Actions

Size

29 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/client/client-model.cpp b/src/client/client-model.cpp
	index d543459..22a2e35 100644
	--- a/src/client/client-model.cpp
	+++ b/src/client/client-model.cpp
	@@ -1,103 +1,105 @@
	/*
	* Copyright (C) 2020 Tusooa Zhu <tusooa@vista.aero>
	*
	* This file is part of libkazv.
	*
	* libkazv is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* libkazv is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with libkazv. If not, see <https://www.gnu.org/licenses/>.
	*/


	#include <lager/util.hpp>
	#include <lager/context.hpp>
	#include <functional>

	#include <immer/flex_vector_transient.hpp>

	+#include "debug.hpp"
	+
	#include "client-model.hpp"

	#include "actions/states.hpp"
	#include "actions/auth.hpp"
	#include "actions/membership.hpp"
	#include "actions/paginate.hpp"
	#include "actions/send.hpp"
	#include "actions/states.hpp"
	#include "actions/sync.hpp"
	#include "actions/ephemeral.hpp"
	#include "actions/content.hpp"

	namespace Kazv
	{
	auto ClientModel::update(ClientModel m, Action a) -> Result
	{
	return lager::match(std::move(a))(
	[&](Error::Action a) -> Result {
	m.error = Error::update(m.error, a);
	return {std::move(m), lager::noop};
	},

	[&](RoomListAction a) -> Result {
	m.roomList = RoomListModel::update(std::move(m.roomList), a);
	return {std::move(m), lager::noop};
	},
	[&](ResubmitJobAction a) -> Result {
	m.addJob(std::move(a.job));
	return { std::move(m), lager::noop };
	},
	[&](auto a) -> decltype(updateClient(m, a)) {
	return updateClient(m, a);
	},
	#define RESPONSE_FOR(_jobId) \
	if (r.jobId() == #_jobId) { \
	return processResponse(m, _jobId##Response{std::move(r)}); \
	}

	[&](ProcessResponseAction a) -> Result {
	auto r = std::move(a.response);

	// auth
	RESPONSE_FOR(Login);
	// paginate
	RESPONSE_FOR(GetRoomEvents);
	// sync
	RESPONSE_FOR(Sync);
	RESPONSE_FOR(DefineFilter);
	// membership
	RESPONSE_FOR(CreateRoom);
	RESPONSE_FOR(InviteUser);
	RESPONSE_FOR(JoinRoomById);
	RESPONSE_FOR(JoinRoom);
	RESPONSE_FOR(LeaveRoom);
	RESPONSE_FOR(ForgetRoom);
	// send
	RESPONSE_FOR(SendMessage);
	// states
	RESPONSE_FOR(GetRoomState);
	RESPONSE_FOR(SetRoomStateWithKey);
	// ephemeral
	RESPONSE_FOR(SetTyping);
	RESPONSE_FOR(PostReceipt);
	RESPONSE_FOR(SetReadMarker);
	// content
	RESPONSE_FOR(UploadContent);
	RESPONSE_FOR(GetContent);
	RESPONSE_FOR(GetContentThumbnail);

	m.addTrigger(UnrecognizedResponse{std::move(r)});
	return { std::move(m), lager::noop };
	}

	#undef RESPONSE_FOR
	);
	}
	}
	diff --git a/src/client/room/room-model.cpp b/src/client/room/room-model.cpp
	index 796e3bf..0fc607a 100644
	--- a/src/client/room/room-model.cpp
	+++ b/src/client/room/room-model.cpp
	@@ -1,88 +1,94 @@
	/*
	* Copyright (C) 2020 Tusooa Zhu
	*
	* This file is part of libkazv.
	*
	* libkazv is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* libkazv is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with libkazv. If not, see <https://www.gnu.org/licenses/>.
	*/


	#include <lager/util.hpp>
	#include <zug/sequence.hpp>
	#include <zug/transducer/map.hpp>

	+#include "debug.hpp"
	+
	#include "room-model.hpp"
	#include "cursorutil.hpp"


	namespace Kazv
	{
	RoomModel RoomModel::update(RoomModel r, Action a)
	{
	return lager::match(std::move(a))(
	[&](AddStateEventsAction a) {
	r.stateEvents = merge(std::move(r.stateEvents), a.stateEvents, keyOfState);
	return r;
	},
	[&](AppendTimelineAction a) {
	auto eventIds = intoImmer(immer::flex_vector<std::string>(),
	zug::map(keyOfTimeline), a.events);
	r.timeline = r.timeline + eventIds;
	r.messages = merge(std::move(r.messages), a.events, keyOfTimeline);
	return r;
	},
	[&](PrependTimelineAction a) {
	auto eventIds = intoImmer(immer::flex_vector<std::string>(),
	zug::map(keyOfTimeline), a.events);
	r.timeline = eventIds + r.timeline;
	r.messages = merge(std::move(r.messages), a.events, keyOfTimeline);
	r.paginateBackToken = a.paginateBackToken;
	// if there are no more events we should not allow further paginating
	r.canPaginateBack = a.events.size() != 0;
	return r;
	},
	[&](AddAccountDataAction a) {
	r.accountData = merge(std::move(r.accountData), a.events, keyOfAccountData);
	return r;
	},
	[&](ChangeMembershipAction a) {
	r.membership = a.membership;
	return r;
	},
	[&](ChangeInviteStateAction a) {
	r.inviteState = merge(immer::map<KeyOfState, Event>{}, a.events, keyOfState);
	return r;
	},
	[&](AddEphemeralAction a) {
	r.ephemeral = merge(std::move(r.ephemeral), a.events, keyOfEphemeral);
	return r;
	+ },
	+ [&](SetLocalDraftAction a) {
	+ r.localDraft = a.localDraft;
	+ return r;
	}
	);
	}

	RoomListModel RoomListModel::update(RoomListModel l, Action a)
	{
	return lager::match(std::move(a))(
	- [=](UpdateRoomAction a) mutable {
	+ [&](UpdateRoomAction a) {
	l.rooms = std::move(l.rooms)
	.update(a.roomId,
	[=](RoomModel oldRoom) {
	oldRoom.roomId = a.roomId; // in case it is a new room
	return RoomModel::update(std::move(oldRoom), a.roomAction);
	});
	return l;
	}
	);
	}
	}
	diff --git a/src/client/room/room-model.hpp b/src/client/room/room-model.hpp
	index 734da22..71abcee 100644
	--- a/src/client/room/room-model.hpp
	+++ b/src/client/room/room-model.hpp
	@@ -1,180 +1,190 @@
	/*
	* Copyright (C) 2020 Tusooa Zhu
	*
	* This file is part of libkazv.
	*
	* libkazv is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* libkazv is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with libkazv. If not, see <https://www.gnu.org/licenses/>.
	*/


	#pragma once

	#include <lager/debug/cereal/struct.hpp>
	#include <lager/debug/cereal/immer_flex_vector.hpp>

	#include <string>
	#include <variant>
	#include <immer/flex_vector.hpp>
	#include <immer/map.hpp>

	#include <csapi/sync.hpp>
	#include <event.hpp>

	#include "data/cereal_map.hpp"

	#include "clientutil.hpp"

	namespace Kazv
	{
	struct AddStateEventsAction
	{
	immer::flex_vector<Event> stateEvents;
	};

	struct AppendTimelineAction
	{
	immer::flex_vector<Event> events;
	};

	struct PrependTimelineAction
	{
	immer::flex_vector<Event> events;
	std::string paginateBackToken;
	};

	struct AddAccountDataAction
	{
	immer::flex_vector<Event> events;
	};

	struct ChangeMembershipAction
	{
	RoomMembership membership;
	};

	struct ChangeInviteStateAction
	{
	immer::flex_vector<Event> events;
	};

	struct AddEphemeralAction
	{
	EventList events;
	};

	+ struct SetLocalDraftAction
	+ {
	+ std::string localDraft;
	+ };
	+
	struct RoomModel
	{
	using Membership = RoomMembership;

	std::string roomId;
	immer::map<KeyOfState, Event> stateEvents;
	immer::map<KeyOfState, Event> inviteState;
	immer::flex_vector<std::string> timeline;
	immer::map<std::string, Event> messages;
	immer::map<std::string, Event> accountData;
	Membership membership{};
	std::string paginateBackToken;
	/// whether this room has earlier events to be fetched
	bool canPaginateBack{true};

	immer::map<std::string, Event> ephemeral;

	+ std::string localDraft;
	+
	using Action = std::variant<
	AddStateEventsAction,
	AppendTimelineAction,
	PrependTimelineAction,
	AddAccountDataAction,
	ChangeMembershipAction,
	ChangeInviteStateAction,
	- AddEphemeralAction
	+ AddEphemeralAction,
	+ SetLocalDraftAction
	>;

	static RoomModel update(RoomModel r, Action a);
	};

	using RoomAction = RoomModel::Action;

	inline bool operator==(RoomModel a, RoomModel b)
	{
	return a.roomId == b.roomId
	&& a.stateEvents == b.stateEvents
	&& a.inviteState == b.inviteState
	&& a.timeline == b.timeline
	&& a.messages == b.messages
	&& a.accountData == b.accountData
	&& a.membership == b.membership
	&& a.paginateBackToken == b.paginateBackToken
	- && a.canPaginateBack == b.canPaginateBack;
	+ && a.canPaginateBack == b.canPaginateBack
	+ && a.localDraft == b.localDraft;
	}

	struct UpdateRoomAction
	{
	std::string roomId;
	RoomAction roomAction;
	};

	struct RoomListModel
	{
	immer::map<std::string, RoomModel> rooms;

	inline auto at(std::string id) const { return rooms.at(id); }
	inline auto operator[](std::string id) const { return rooms[id]; }
	inline bool has(std::string id) const { return rooms.find(id); }

	using Action = std::variant<
	UpdateRoomAction
	>;
	static RoomListModel update(RoomListModel l, Action a);
	};

	using RoomListAction = RoomListModel::Action;

	inline bool operator==(RoomListModel a, RoomListModel b)
	{
	return a.rooms == b.rooms;
	}

	#ifndef NDEBUG
	LAGER_CEREAL_STRUCT(AddStateEventsAction);
	LAGER_CEREAL_STRUCT(AppendTimelineAction);
	LAGER_CEREAL_STRUCT(PrependTimelineAction);
	LAGER_CEREAL_STRUCT(AddAccountDataAction);
	LAGER_CEREAL_STRUCT(ChangeMembershipAction);
	+ LAGER_CEREAL_STRUCT(SetLocalDraftAction);
	LAGER_CEREAL_STRUCT(ChangeInviteStateAction);
	LAGER_CEREAL_STRUCT(UpdateRoomAction);
	#endif

	template<class Archive>
	void serialize(Archive &ar, RoomModel &r, std::uint32_t const /version/)
	{
	ar(r.roomId,
	r.stateEvents,
	r.inviteState,
	r.timeline,
	r.messages,
	r.accountData,
	r.membership,
	r.paginateBackToken,
	r.canPaginateBack);
	}

	template<class Archive>
	void serialize(Archive &ar, RoomListModel &l, std::uint32_t const /version/)
	{
	ar(l.rooms);
	}
	}

	CEREAL_CLASS_VERSION(Kazv::RoomModel, 0);
	CEREAL_CLASS_VERSION(Kazv::RoomListModel, 0);
	diff --git a/src/client/room/room.hpp b/src/client/room/room.hpp
	index ac04a51..8d8c9e0 100644
	--- a/src/client/room/room.hpp
	+++ b/src/client/room/room.hpp
	@@ -1,322 +1,331 @@
	/*
	* Copyright (C) 2020 Tusooa Zhu
	*
	* This file is part of libkazv.
	*
	* libkazv is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* libkazv is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with libkazv. If not, see <https://www.gnu.org/licenses/>.
	*/

	#pragma once

	#include <lager/reader.hpp>
	#include <lager/context.hpp>
	#include <lager/with.hpp>
	#include <lager/lenses/optional.hpp>
	#include <zug/transducer/map.hpp>
	#include <zug/transducer/filter.hpp>
	#include <zug/sequence.hpp>
	#include <immer/flex_vector_transient.hpp>

	+#include "debug.hpp"
	+
	#include "client-model.hpp"
	#include "room-model.hpp"
	#include "client/cursorutil.hpp"

	namespace Kazv
	{
	class Room
	{
	public:
	inline Room(lager::reader<RoomModel> room, lager::context<ClientAction> ctx)
	: m_room(room)
	, m_ctx(ctx) {}

	/* lager::reader<MapT<KeyOfState, Event>> */
	inline auto stateEvents() const {
	return m_room
	[&RoomModel::stateEvents];
	}

	/* lager::reader<std::optional<Event>> */
	inline auto stateOpt(KeyOfState k) const {
	return stateEvents()
	[std::move(k)];
	}

	/* lager::reader<Event> */
	inline auto state(KeyOfState k) const {
	return stateOpt(k)
	[lager::lenses::or_default];
	}

	/* lager::reader<RangeT<Event>> */
	inline auto timelineEvents() const {
	return m_room
	.xform(zug::map([](auto r) {
	auto messages = r.messages;
	auto timeline = r.timeline;
	return intoImmer(
	immer::flex_vector<Event>{},
	zug::map([=](auto eventId) {
	return messages[eventId];
	}),
	timeline);
	}));
	}

	/* lager::reader<std::string> */
	inline auto name() const {
	using namespace lager::lenses;
	return stateEvents()
	[KeyOfState{"m.room.name", ""}]
	[or_default]
	.xform(zug::map([](Event ev) {
	auto content = ev.content().get();
	return
	content.contains("name")
	? std::string(content["name"])
	// TODO: use heroes to generate a name
	: "<no name>";
	}));
	}

	/* lager::reader<RangeT<std::string>> */
	inline auto members() const {
	using MemberNode = std::pair<std::string, Kazv::Event>;
	auto memberNameTransducer =
	zug::filter(
	[](auto val) {
	auto [k, v] = val;
	auto [type, stateKey] = k;
	return type == "m.room.member"s;
	})
	\| zug::map(
	[](auto val) {
	auto [k, v] = val;
	auto [type, stateKey] = k;
	return MemberNode{stateKey, v};
	})
	\| zug::filter(
	[](auto val) {
	auto [stateKey, ev] = val;
	return ev.content().get()
	.at("membership"s) == "join"s;
	})
	\| zug::map(
	[](auto val) {
	auto [stateKey, ev] = val;
	return stateKey;
	});

	return m_room
	[&RoomModel::stateEvents]
	.xform(zug::map(
	[=](auto eventMap) {
	return intoImmer(
	immer::flex_vector<std::string>{},
	memberNameTransducer,
	eventMap);
	}));

	}

	/* lager::reader<std::optional<Event>> */
	inline auto memberEventFor(std::string userId) const {
	return m_room
	[&RoomModel::stateEvents]
	.xform(containerMap(immer::flex_vector<Event>{},
	zug::filter([=](auto val) {
	auto [k, v] = val;
	auto [type, stateKey] = k;
	return type == "m.room.member"s && stateKey == userId;
	}) // -> RangeT<pair<KeyofState{...}, Event>>
	\| zug::map([](auto val) {
	auto [k, event] = val;
	return event;
	})))
	[0];
	}

	lager::reader<bool> encrypted() const;

	/lager::reader<std::string>/
	KAZV_WRAP_ATTR(RoomModel, m_room, roomId);
	/lager::reader<RoomMembership>/
	KAZV_WRAP_ATTR(RoomModel, m_room, membership);
	+ /lager::reader<std::string>/
	+ KAZV_WRAP_ATTR(RoomModel, m_room, localDraft);
	+
	+ inline void setLocalDraft(std::string localDraft) const {
	+ using namespace CursorOp;
	+ m_ctx.dispatch(UpdateRoomAction{+roomId(), SetLocalDraftAction{localDraft}});
	+ }

	inline void sendMessage(Event msg) const {
	using namespace CursorOp;
	m_ctx.dispatch(SendMessageAction{+roomId(), msg});
	}

	inline void sendTextMessage(std::string text) const {
	json j{
	{"type", "m.room.message"},
	{"content", {
	{"msgtype", "m.text"},
	{"body", text}
	}
	}
	};
	Event e{j};
	sendMessage(e);
	}

	inline void sendStateEvent(Event state) const {
	using namespace CursorOp;
	m_ctx.dispatch(SendStateEventAction{+roomId(), state});
	}

	inline void setName(std::string name) const {
	json j{
	{"type", "m.room.name"},
	{"content", {
	{"name", name}
	}
	}
	};
	Event e{j};
	sendStateEvent(e);
	}

	// lager::reader<std::string>
	inline auto topic() const {
	using namespace lager::lenses;
	return stateEvents()
	[KeyOfState{"m.room.topic", ""}]
	[or_default]
	.xform(eventContent
	\| jsonAtOr("topic"s, ""s));
	}

	inline void setTopic(std::string topic) const {
	json j{
	{"type", "m.room.topic"},
	{"content", {
	{"topic", topic}
	}
	}
	};
	Event e{j};
	sendStateEvent(e);
	}

	inline void invite(std::string userId) const {
	using namespace CursorOp;
	m_ctx.dispatch(InviteToRoomAction{+roomId(), userId});
	}

	/* lager::reader<MapT<std::string, Event>> */
	inline auto ephemeralEvents() const {
	return m_room
	[&RoomModel::ephemeral];
	}

	/* lager::reader<std::optional<Event>> */
	inline auto ephemeralOpt(std::string type) const {
	return m_room
	[&RoomModel::ephemeral]
	[type];
	}

	/* lager::reader<Event> */
	inline auto ephemeral(std::string type) const {
	return m_room
	[&RoomModel::ephemeral]
	[type]
	[lager::lenses::or_default];
	}

	/* lager::reader<RangeT<std::string>> */
	inline auto typingUsers() const {
	using namespace lager::lenses;
	return ephemeral("m.typing")
	.xform(eventContent
	\| jsonAtOr("user_ids",
	immer::flex_vector<std::string>{}));
	}

	inline void setTyping(bool typing, std::optional<int> timeoutMs) const {
	using namespace CursorOp;
	m_ctx.dispatch(SetTypingAction{+roomId(), typing, timeoutMs});
	}

	/* lager::reader<MapT<std::string, Event>> */
	inline auto accountDataEvents() const {
	return m_room
	[&RoomModel::accountData];
	}

	/* lager::reader<std::optional<Event>> */
	inline auto accountDataOpt(std::string type) const {
	return m_room
	[&RoomModel::accountData]
	[type];
	}

	/* lager::reader<Event> */
	inline auto accountData(std::string type) const {
	return m_room
	[&RoomModel::accountData]
	[type]
	[lager::lenses::or_default];
	}

	/* lager::reader<std::string> */
	inline auto readMarker() const {
	using namespace lager::lenses;
	return accountData("m.fully_read")
	.xform(eventContent
	\| jsonAtOr("event_id", std::string{}));
	}

	inline void leave() const {
	using namespace CursorOp;
	m_ctx.dispatch(LeaveRoomAction{+roomId()});
	}

	inline void forget() const {
	using namespace CursorOp;
	m_ctx.dispatch(ForgetRoomAction{+roomId()});
	}

	/* lager::reader<JsonWrap> */
	inline auto avatar() const {
	return state(KeyOfState{"m.room.avatar", ""})
	.xform(eventContent);
	}

	/* lager::reader<RangeT<std::string>> */
	inline auto pinnedEvents() const {
	return state(KeyOfState{"m.room.pinned_events", ""})
	.xform(eventContent
	\| jsonAtOr("pinned", immer::flex_vector<std::string>{}));
	}

	inline void setPinnedEvents(immer::flex_vector<std::string> eventIds) const {
	json j{
	{"type", "m.room.pinned_events"},
	{"content", {
	{"pinned", eventIds}
	}
	}
	};
	Event e{j};
	sendStateEvent(e);
	}

	private:
	lager::reader<RoomModel> m_room;
	lager::context<ClientAction> m_ctx;
	};
	}
	diff --git a/src/examples/basic/main.cpp b/src/examples/basic/main.cpp
	index b8031ea..766c814 100644
	--- a/src/examples/basic/main.cpp
	+++ b/src/examples/basic/main.cpp
	@@ -1,147 +1,147 @@
	/*
	* Copyright (C) 2020 Tusooa Zhu
	*
	* This file is part of libkazv.
	*
	* libkazv is free software: you can redistribute it and/or modify
	* it under the terms of the GNU Affero General Public License as
	* published by the Free Software Foundation, either version 3 of the
	* License, or (at your option) any later version.
	*
	* libkazv is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU Affero General Public License for more details.
	*
	* You should have received a copy of the GNU Affero General Public License
	* along with libkazv. If not, see <https://www.gnu.org/licenses/>.
	*/


	#include <string>
	#include <iostream>
	#include <fstream>
	#include <lager/store.hpp>
	#include <lager/event_loop/boost_asio.hpp>
	#include <lager/resources_path.hpp>
	#include <boost/asio.hpp>

	#ifndef NDEBUG
	#include <lager/debug/debugger.hpp>
	#include <lager/debug/http_server.hpp>
	#endif

	#include <cprjobhandler.hpp>
	#include <lagerstoreeventemitter.hpp>
	#include <sdk.hpp>

	#include "commands.hpp"

	using namespace std::string_literals;

	int main(int argc, char *argv[])
	{

	if (argc <= 1) {
	std::cerr << "Usage: basicexample <auth-file-name>\n\n"
	<< "auth file is a text file with these lines:\n"
	<< "mode(pw or token)\n"
	<< "homeserver address\n"
	<< "username (if pw) or userid (if token)\n"
	<< "password (if pw) or token (if token)\n"
	<< "deviceId (if token) or blank (if pw)\n\n"
	<< "For example:\n"
	<< "pw\n"
	<< "https://some.server.org\n"
	<< "someUserName\n"
	<< "somePa$$w0rd\n";
	return 1;
	}

	boost::asio::io_context ioContext;
	auto eventEmitter =
	Kazv::LagerStoreEventEmitter(lager::with_boost_asio_event_loop{ioContext.get_executor()});

	- Kazv::CprJobHandler jobHandler(Kazv::CprJobHandler{ioContext.get_executor()});
	+ Kazv::CprJobHandler jobHandler{ioContext.get_executor()};

	// #ifndef NDEBUG
	// auto debugger = lager::http_debug_server{argc, (const char **)argv, 8080,
	// lager::resources_path()
	// //"./_deps/lager-src/resources"
	// };
	// #endif
	auto sdk = Kazv::makeSdk(
	Kazv::SdkModel{},
	static_cast<Kazv::CprJobHandler &>(jobHandler),
	static_cast<Kazv::EventInterface &>(eventEmitter),
	lager::with_boost_asio_event_loop{ioContext.get_executor()},
	// #ifndef NDEBUG
	// zug::map([](auto &&m) -> Kazv::SdkModel {
	// return std::forward<decltype(m)>(m);
	// }),
	// lager::with_debugger(debugger)
	// #else
	zug::identity
	// #endif
	);

	auto store = sdk.context();
	auto c = sdk.client();

	/*
	auto watchable = eventEmitter.watchable();
	watchable.after<Kazv::ReceivingRoomTimelineEvent>(
	[](auto e) {
	auto [event, roomId] = e;
	std::cout << "\033[1;32mreceiving event " << event.id()
	<< " in " << roomId
	<< " from " << event.sender()
	<< ": " << event.content().get().dump() << "\033[0m"
	<< std::endl;
	});
	*/
	- std::thread([&] { ioContext.run(); }).detach();

	{
	std::ifstream auth(argv[1]);
	if (! auth) {
	std::cerr << "Cannot open auth file " << argv[1] << "\n";
	return 1;
	}
	std::string mode;
	std::string homeserver;
	std::string username;
	std::getline(auth, mode);
	std::getline(auth, homeserver);
	std::getline(auth, username);

	if (mode == "token") {
	std::string token;
	std::string deviceId;
	std::getline(auth, token);
	std::getline(auth, deviceId);
	c.tokenLogin(homeserver, username, token, deviceId);
	} else {
	std::string password;
	std::getline(auth, password);
	c.passwordLogin(homeserver, username, password, "libkazv basic example");
	std::cout << "password login action sent" << std::endl;
	}

	}

	std::cout << "starting event loop" << std::endl;
	+ std::thread([&] { ioContext.run(); }).detach();

	std::size_t command = 1;
	while (true) {
	std::cout << "\033[1;33mCommand[" << command << "]: \033[0m\n";
	std::string l;
	if (! std::getline(std::cin, l)) {
	break;
	}
	parse(l, c);
	++command;
	}

	jobHandler.stop();
	}

File Metadata

Mime Type: text/x-diff
Expires: Sun, Jan 19, 4:06 PM (1 d, 4 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 55311
Default Alt Text: (29 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions