From 41b976bd6a501c9f95e3cc32563b5f20b87e6d4e Mon Sep 17 00:00:00 2001 From: rexy712 Date: Mon, 2 Mar 2020 17:09:38 -0800 Subject: [PATCH] Start removing raii components into separate library. Strings, binary, and filerd were first to go --- include/matrix/auth.hpp | 10 +- include/matrix/client.hpp | 29 ++- include/matrix/connection.hpp | 40 ++-- include/matrix/events.hpp | 32 +-- include/matrix/fat_strings.hpp | 38 +-- include/matrix/iterable.hpp | 16 +- include/matrix/json_targets.hpp | 300 ++++++++++++------------ include/matrix/rest/client_url_list.hpp | 34 +-- include/matrix/rest/room_url_list.hpp | 54 ++--- include/matrix/rest/session_urls.hpp | 10 +- include/matrix/rest/urls_common.hpp | 6 +- include/matrix/roomcxn.hpp | 40 ++-- include/matrix/session.hpp | 24 +- include/matrix/session_info.hpp | 8 +- include/matrix/sync_response.hpp | 8 +- include/matrix/upload_info.hpp | 24 +- include/raii/binary.hpp | 172 -------------- include/raii/binary_string_conv.hpp | 71 ------ include/raii/curl_string.hpp | 4 +- include/raii/curler.hpp | 8 +- include/raii/default_allocator.hpp | 48 ---- include/raii/filerd.hpp | 68 ------ include/raii/rjp_iterator.hpp | 2 +- include/raii/rjp_string.hpp | 10 +- include/raii/string.hpp | 32 --- include/raii/string_base.hpp | 294 ----------------------- include/raii/string_base.tpp | 247 ------------------- include/raii/util.hpp | 14 +- makefile | 2 +- src/matrix/client.cpp | 52 ++-- src/matrix/connection.cpp | 64 ++--- src/matrix/events.cpp | 42 ++-- src/matrix/fat_strings.cpp | 88 +++---- src/matrix/iterable.cpp | 10 +- src/matrix/rest/client_url_list.cpp | 42 ++-- src/matrix/rest/room_url_list.cpp | 62 ++--- src/matrix/rest/session_urls.cpp | 16 +- src/matrix/roomcxn.cpp | 70 +++--- src/matrix/session.cpp | 42 ++-- src/matrix/sync_response.cpp | 10 +- src/raii/binary.cpp | 37 --- src/raii/curler.cpp | 8 +- src/raii/filerd.cpp | 112 --------- src/raii/string_base.cpp | 49 ---- src/raii/util.cpp | 14 +- src/test.cpp | 35 +-- 46 files changed, 634 insertions(+), 1764 deletions(-) delete mode 100644 include/raii/binary.hpp delete mode 100644 include/raii/binary_string_conv.hpp delete mode 100644 include/raii/default_allocator.hpp delete mode 100644 include/raii/filerd.hpp delete mode 100644 include/raii/string.hpp delete mode 100644 include/raii/string_base.hpp delete mode 100644 include/raii/string_base.tpp delete mode 100644 src/raii/binary.cpp delete mode 100644 src/raii/filerd.cpp delete mode 100644 src/raii/string_base.cpp diff --git a/include/matrix/auth.hpp b/include/matrix/auth.hpp index 67a1b17..6da7520 100644 --- a/include/matrix/auth.hpp +++ b/include/matrix/auth.hpp @@ -24,11 +24,11 @@ namespace matrix{ struct auth_data{ - raii::string name; - raii::string pass; - raii::string homeserver; - raii::string useragent; - raii::string access_token; + rexy::string name; + rexy::string pass; + rexy::string homeserver; + rexy::string useragent; + rexy::string access_token; operator bool(void)const{ return (name && pass && homeserver); diff --git a/include/matrix/client.hpp b/include/matrix/client.hpp index 9954664..8a35f5a 100644 --- a/include/matrix/client.hpp +++ b/include/matrix/client.hpp @@ -19,9 +19,8 @@ #ifndef MATRIX_CLIENT_HPP #define MATRIX_CLIENT_HPP -#include "raii/string.hpp" +#include #include "raii/rjp_string.hpp" -#include "raii/filerd.hpp" #include "matrix/session_info.hpp" #include "matrix/upload_info.hpp" #include "matrix/connection.hpp" @@ -58,22 +57,22 @@ namespace matrix{ * Note name must be safe to be placed in a json string. * Returns: true if the operation was successful. */ - netreturn set_display_name(const raii::string_base&); + netreturn set_display_name(const rexy::string_base&); /* * Sets the url of the user's profile picture on the homeserver. * Note url must be safe to be placed in a json string. * Returns: true if the operation was successful. */ - netreturn set_profile_picture(const raii::string_base&); + netreturn set_profile_picture(const rexy::string_base&); - netreturn set_presence(const raii::string_base& status); - netreturn get_presence(const raii::string_base& userid); + netreturn set_presence(const rexy::string_base& status); + netreturn get_presence(const rexy::string_base& userid); /* * Gets the display name of the logged in user from the homeserver. * Returns: the display name on success, an empty string on failure. */ netreturn get_display_name(void)const; - netreturn get_display_name(const raii::string_base&)const; + netreturn get_display_name(const rexy::string_base&)const; /* * Gets the profile picture url of the logged in user from the homeserver. * Returns: the profile picture url on success, an empty string on failure. @@ -83,7 +82,7 @@ namespace matrix{ * Lookup a room id given a room alias. * Returns: the room id of the associated room on success, empty string on failure. */ - netreturn room_alias_to_id(const raii::string_base& alias)const; + netreturn room_alias_to_id(const rexy::string_base& alias)const; /* * Get a list of rooms the logged in user is a member of. @@ -95,7 +94,7 @@ namespace matrix{ * Create a new room on the logged in user's homeserver. Assign an alias to the room. * Returns: the room id of the newly created room on success, an empty string on failure. */ - netreturn create_room(const raii::string_base& name, const raii::string_base& alias)const; + netreturn create_room(const rexy::string_base& name, const rexy::string_base& alias)const; /* * Create a new matrix::roomcxn object for the given roomid. @@ -103,8 +102,8 @@ namespace matrix{ * access token, or homeserver after creating a roomcxn MUST be synchronized between threads. * Returns: a new matrix::roomcxn for the given roomid. */ - roomcxn spawn_room(const raii::string_base& roomid)const; - roomcxn spawn_room(raii::string&& roomid)const; + roomcxn spawn_room(const rexy::string_base& roomid)const; + roomcxn spawn_room(rexy::string&& roomid)const; //NOTE alias equivalents just give the uploaded file a name other than the filename. @@ -139,9 +138,9 @@ namespace matrix{ netreturn create_thumbnail(uploaded_image& info)const; netreturn create_thumbnail(uploaded_video& video)const; - raii::binary download_file(const raii::string_base& url); + rexy::binary download_file(const rexy::string_base& url); template - bool download_file(const raii::string_base& url, DLHandler&& dl){ + bool download_file(const rexy::string_base& url, DLHandler&& dl){ _get_curl_setup(m_urls->file_download(*m_ses, url)); m_curl.setwritefun(_download_dispatch); m_curl.setwritedata(&dl); @@ -150,8 +149,8 @@ namespace matrix{ return true; } template - bool download_file(const raii::string_base& server, const raii::string_base& media_id, DLHandler&& dl){ - raii::string url = "mxc://"_ss + server + "/"_ss + media_id; + bool download_file(const rexy::string_base& server, const rexy::string_base& media_id, DLHandler&& dl){ + rexy::string url = "mxc://"_ss + server + "/"_ss + media_id; return download_file(url, std::forward(dl)); } diff --git a/include/matrix/connection.hpp b/include/matrix/connection.hpp index 214a630..89b937e 100644 --- a/include/matrix/connection.hpp +++ b/include/matrix/connection.hpp @@ -20,9 +20,9 @@ #define MATRIX_CONNECTION_HPP #include "raii/curler.hpp" -#include "raii/string.hpp" +#include #include "raii/rjp_string.hpp" -#include "raii/binary.hpp" +#include #include "raii/rjp_ptr.hpp" #include "matrix/session_info.hpp" #include "matrix/netreturn.hpp" @@ -59,7 +59,7 @@ namespace matrix{ * NOT thread safe * Returns: the current useragent. */ - const raii::string& useragent(void)const; + const rexy::string& useragent(void)const; /* * Returns: the http status code of the last operation performed. @@ -73,30 +73,30 @@ namespace matrix{ }; static size_t _reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata); static size_t _binary_reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata); - void _get_curl_setup(const raii::string_base& url)const; - void _post_curl_setup(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header)const; + void _get_curl_setup(const rexy::string_base& url)const; + void _post_curl_setup(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header)const; static size_t _put_read_curl_callback(char* buffer, size_t size, size_t nmemb, void* userdata); - void _put_curl_setup(put_data& data, const raii::string_base& url, const raii::curl_llist& header)const; + void _put_curl_setup(put_data& data, const rexy::string_base& url, const raii::curl_llist& header)const; protected: using binary_callback_fun = size_t(*)(char*, size_t, size_t, void*); using reply_callback_fun = size_t(*)(char*, size_t, size_t, void*); - void _set_curl_useragent(const raii::string_base& useragent); + void _set_curl_useragent(const rexy::string_base& useragent); bool _perform_curl(void)const; - raii::string _get_curl(const raii::string_base& url, reply_callback_fun fun = _reply_curl_callback)const; - raii::binary _get_curl_binary(const raii::string_base& url, binary_callback_fun fun = _binary_reply_curl_callback)const; - raii::string _post_curl(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, reply_callback_fun = _reply_curl_callback)const; - raii::binary _post_curl_binary(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, binary_callback_fun = _binary_reply_curl_callback)const; - raii::string _put_curl(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, reply_callback_fun = _reply_curl_callback)const; - raii::binary _put_curl_binary(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, binary_callback_fun = _binary_reply_curl_callback)const; - netreturn _post_and_find(const raii::string_base& data, const raii::string_base& url, const raii::curl_llist& header, const raii::string_base& target)const; - netreturn _put_and_find(const raii::string_base& data, const raii::string_base& url, const raii::curl_llist& header, const raii::string_base& target)const; - netreturn _get_and_find(const raii::string_base& url, const raii::string_base& search)const; - raii::rjp_string _curl_reply_search(const raii::string_base& reply, const raii::string_base& search)const; - raii::rjp_string _curl_reply_search(const raii::rjp_ptr& root, const raii::string_base& search)const; - void _set_curl_defaults(const raii::string_base& useragent)const; - static netreturn_base _create_netreturn(const raii::string_base& mxjson, int httpstatus); + rexy::string _get_curl(const rexy::string_base& url, reply_callback_fun fun = _reply_curl_callback)const; + rexy::binary _get_curl_binary(const rexy::string_base& url, binary_callback_fun fun = _binary_reply_curl_callback)const; + rexy::string _post_curl(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, reply_callback_fun = _reply_curl_callback)const; + rexy::binary _post_curl_binary(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, binary_callback_fun = _binary_reply_curl_callback)const; + rexy::string _put_curl(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, reply_callback_fun = _reply_curl_callback)const; + rexy::binary _put_curl_binary(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, binary_callback_fun = _binary_reply_curl_callback)const; + netreturn _post_and_find(const rexy::string_base& data, const rexy::string_base& url, const raii::curl_llist& header, const rexy::string_base& target)const; + netreturn _put_and_find(const rexy::string_base& data, const rexy::string_base& url, const raii::curl_llist& header, const rexy::string_base& target)const; + netreturn _get_and_find(const rexy::string_base& url, const rexy::string_base& search)const; + raii::rjp_string _curl_reply_search(const rexy::string_base& reply, const rexy::string_base& search)const; + raii::rjp_string _curl_reply_search(const raii::rjp_ptr& root, const rexy::string_base& search)const; + void _set_curl_defaults(const rexy::string_base& useragent)const; + static netreturn_base _create_netreturn(const rexy::string_base& mxjson, int httpstatus); static netreturn_base _create_netreturn(const raii::rjp_ptr& root, int httpstatus); }; diff --git a/include/matrix/events.hpp b/include/matrix/events.hpp index bd7b37e..42ec8d9 100644 --- a/include/matrix/events.hpp +++ b/include/matrix/events.hpp @@ -20,7 +20,7 @@ #define MATRIX_EVENT_HPP #include "raii/rjp_ptr.hpp" -#include "raii/string_base.hpp" +#include #include "raii/rjp_string.hpp" namespace matrix::sync{ @@ -42,7 +42,7 @@ namespace matrix::sync{ ~event(void) = default; event& operator=(const event&); - raii::static_string type(void)const&; + rexy::static_string type(void)const&; raii::rjp_string type(void)&&; const RJP_value* content(void)const; RJP_value* content(void); @@ -57,16 +57,16 @@ namespace matrix::sync{ class room_event_base { protected: - raii::static_string m_roomid; + rexy::static_string m_roomid; public: room_event_base(void) = default; room_event_base(const room_event_base&) = delete; constexpr room_event_base(room_event_base&&) = default; room_event_base& operator=(const room_event_base&) = default; - constexpr room_event_base(const raii::string_base& roomid): + constexpr room_event_base(const rexy::string_base& roomid): m_roomid(roomid.get(), roomid.length()){} - constexpr const raii::static_string& roomid(void)const{ + constexpr const rexy::static_string& roomid(void)const{ return m_roomid; } }; @@ -84,22 +84,22 @@ namespace matrix::sync{ int m_origin_server_ts; public: room_event(void) = default; - room_event(RJP_value* ev, const raii::string_base& roomid); + room_event(RJP_value* ev, const rexy::string_base& roomid); room_event(const room_event&) = delete; //TODO room_event(room_event&&)noexcept; room_event& operator=(const room_event&) = delete; room_event& operator=(room_event&&); - raii::static_string eventid(void)const&; + rexy::static_string eventid(void)const&; raii::rjp_string eventid(void)&&; - raii::static_string sender(void)const&; + rexy::static_string sender(void)const&; raii::rjp_string sender(void)&&; int origin_server_ts(void)const; const RJP_value* extra(void)const; RJP_value* extra(void); //only for m.room.redacts events - raii::static_string redacts(void)const&; + rexy::static_string redacts(void)const&; raii::rjp_string redacts(void)&&; }; @@ -113,15 +113,15 @@ namespace matrix::sync{ RJP_value* m_prev_content; public: room_state_event(void) = default; - room_state_event(RJP_value* ev, const raii::string_base& roomid); + room_state_event(RJP_value* ev, const rexy::string_base& roomid); room_state_event(const room_state_event&) = delete; //TODO room_state_event(room_state_event&&); room_state_event& operator=(const room_state_event&) = delete; room_state_event& operator=(room_state_event&&); - raii::static_string state_key(void)const&; + rexy::static_string state_key(void)const&; raii::rjp_string state_key(void)&&; - raii::static_string prev_content(void)const&; + rexy::static_string prev_content(void)const&; raii::rjp_string prev_content(void)&&; }; @@ -131,7 +131,7 @@ namespace matrix::sync{ class room_ephemeral_event : public room_event_base, public event { public: - room_ephemeral_event(RJP_value* ev, const raii::string_base& roomid); + room_ephemeral_event(RJP_value* ev, const rexy::string_base& roomid); room_ephemeral_event(const room_ephemeral_event&) = delete; //TODO room_ephemeral_event(room_ephemeral_event&&) = default; }; @@ -144,15 +144,15 @@ namespace matrix::sync{ RJP_value* m_body; RJP_value* m_type; public: - room_message_event(RJP_value* ev, const raii::string_base& roomid); + room_message_event(RJP_value* ev, const rexy::string_base& roomid); room_message_event(const room_message_event&) = delete; room_message_event(room_message_event&&); room_message_event(room_event&&)noexcept; - raii::static_string body(void)const&; + rexy::static_string body(void)const&; raii::rjp_string body(void)&&; - raii::static_string msgtype(void)const&; + rexy::static_string msgtype(void)const&; raii::rjp_string msgtype(void)&&; }; diff --git a/include/matrix/fat_strings.hpp b/include/matrix/fat_strings.hpp index 554ec6f..c8a5ba8 100644 --- a/include/matrix/fat_strings.hpp +++ b/include/matrix/fat_strings.hpp @@ -24,30 +24,30 @@ //these functions should rarely change, so it will still build slowly //but will rarely need rebuilt -#include "raii/string.hpp" +#include #include "matrix/upload_info.hpp" namespace matrix::json{ - raii::static_string _empty(void); + rexy::static_string _empty(void); - raii::string _image_body(const uploaded_image& image); - raii::string _video_body(const uploaded_video& video); - raii::string _file_body(const uploaded_file& video); - raii::string _audio_body(const uploaded_audio& audio); - raii::string _message_body(const raii::string_base& text); - raii::string _notice_body(const raii::string_base& msg); - raii::string _login_password(const raii::string_base& userid, const raii::string_base& password); - raii::string _change_psk_password(const raii::string_base& userid, const raii::string_base& newpass, const raii::string_base& oldpass, const raii::string_base& session); + rexy::string _image_body(const uploaded_image& image); + rexy::string _video_body(const uploaded_video& video); + rexy::string _file_body(const uploaded_file& video); + rexy::string _audio_body(const uploaded_audio& audio); + rexy::string _message_body(const rexy::string_base& text); + rexy::string _notice_body(const rexy::string_base& msg); + rexy::string _login_password(const rexy::string_base& userid, const rexy::string_base& password); + rexy::string _change_psk_password(const rexy::string_base& userid, const rexy::string_base& newpass, const rexy::string_base& oldpass, const rexy::string_base& session); - raii::string _displayname_set(const raii::string_base& newname); - raii::string _avatar_set(const raii::string_base& mediaurl); - raii::string _presence_set(const raii::string_base& status); - raii::string _create_room(const raii::string_base& name, const raii::string_base& alias); - raii::string _userid(const raii::string_base& id); - raii::string _userid_reason(const raii::string_base& id, const raii::string_base& reason); - raii::string _typing(bool active, int timeout); - raii::string _redact(const raii::string_base& reason); - raii::string _room_upgrade(int version); + rexy::string _displayname_set(const rexy::string_base& newname); + rexy::string _avatar_set(const rexy::string_base& mediaurl); + rexy::string _presence_set(const rexy::string_base& status); + rexy::string _create_room(const rexy::string_base& name, const rexy::string_base& alias); + rexy::string _userid(const rexy::string_base& id); + rexy::string _userid_reason(const rexy::string_base& id, const rexy::string_base& reason); + rexy::string _typing(bool active, int timeout); + rexy::string _redact(const rexy::string_base& reason); + rexy::string _room_upgrade(int version); } #endif diff --git a/include/matrix/iterable.hpp b/include/matrix/iterable.hpp index 7f7aa23..6061626 100644 --- a/include/matrix/iterable.hpp +++ b/include/matrix/iterable.hpp @@ -20,7 +20,7 @@ #define MATRIX_ITERABLE_HPP #include "matrix/events.hpp" -#include "raii/string_base.hpp" +#include #include "raii/rjp_string.hpp" #include "raii/rjp_iterator.hpp" @@ -64,11 +64,11 @@ namespace matrix::sync{ { protected: raii::rjp_array_iterator m_event; - raii::static_string m_roomid; + rexy::static_string m_roomid; public: constexpr room_event_iterator(void): m_event(nullptr), m_roomid(){} - constexpr room_event_iterator(RJP_value* v, const raii::string_base& roomid): + constexpr room_event_iterator(RJP_value* v, const rexy::string_base& roomid): m_event(v), m_roomid(roomid){} constexpr room_event_iterator(const room_event_iterator& i): m_event(i.m_event), m_roomid(i.m_roomid){} @@ -94,7 +94,7 @@ namespace matrix::sync{ constexpr T operator*(void){ return T(*m_event, m_roomid); } - constexpr const raii::static_string& roomid(void)const{ + constexpr const rexy::static_string& roomid(void)const{ return m_roomid; } }; @@ -137,7 +137,7 @@ namespace matrix::sync{ iterator m_event; public: constexpr iterable_room_event_base(void) = default; - constexpr iterable_room_event_base(RJP_value* ev, const raii::string_base& roomid): + constexpr iterable_room_event_base(RJP_value* ev, const rexy::string_base& roomid): m_event(ev, roomid){} constexpr iterable_room_event_base(const iterable_room_event_base& i): m_event(i.m_event){} @@ -189,10 +189,10 @@ namespace matrix::sync{ raii::rjp_ptr m_root; public: constexpr roomcxn_event_list_base(void) = default; - roomcxn_event_list_base(raii::rjp_ptr& root, RJP_value* event, const raii::string_base& roomid); - raii::static_string start_token(void)const&; + roomcxn_event_list_base(raii::rjp_ptr& root, RJP_value* event, const rexy::string_base& roomid); + rexy::static_string start_token(void)const&; raii::rjp_string start_token(void)&&; - raii::static_string end_token(void)const&; + rexy::static_string end_token(void)const&; raii::rjp_string end_token(void)&&; }; extern template class roomcxn_event_list_base; diff --git a/include/matrix/json_targets.hpp b/include/matrix/json_targets.hpp index a12268f..3092e92 100644 --- a/include/matrix/json_targets.hpp +++ b/include/matrix/json_targets.hpp @@ -1,97 +1,97 @@ #ifndef MATRIX_JSON_TARGETS_HPP #define MATRIX_JSON_TARGETS_HPP -#include "raii/string_base.hpp" +#include namespace matrix::json{ - constexpr raii::static_string True(void){return "true"_ss;} - constexpr raii::static_string False(void){return "false"_ss;} - constexpr raii::static_string reason(void){return "reason"_ss;} + constexpr rexy::static_string True(void){return "true"_ss;} + constexpr rexy::static_string False(void){return "false"_ss;} + constexpr rexy::static_string reason(void){return "reason"_ss;} namespace keys{ - constexpr raii::static_string error(void){return "error"_ss;} - constexpr raii::static_string errcode(void){return "errcode"_ss;} - constexpr raii::static_string retry_after(void){return "retry_after_ms"_ss;} - constexpr raii::static_string joined(void){return "joined"_ss;} - constexpr raii::static_string chunk(void){return "chunk"_ss;} - constexpr raii::static_string newversion(void){return "new_version"_ss;} - constexpr raii::static_string presence(void){return "presence"_ss;} - constexpr raii::static_string displayname(void){return "displayname"_ss;} - constexpr raii::static_string avatarurl(void){return "avatar_url"_ss;} - constexpr raii::static_string joinedrooms(void){return "joined_rooms"_ss;} - constexpr raii::static_string contenturi(void){return "content_uri"_ss;} - constexpr raii::static_string name(void){return "name"_ss;} - constexpr raii::static_string roomaliasname(void){return "room_alias_name"_ss;} - constexpr raii::static_string typing(void){return "typing"_ss;} - constexpr raii::static_string timeout(void){return "timeout"_ss;} - constexpr raii::static_string session(void){return "session"_ss;} + constexpr rexy::static_string error(void){return "error"_ss;} + constexpr rexy::static_string errcode(void){return "errcode"_ss;} + constexpr rexy::static_string retry_after(void){return "retry_after_ms"_ss;} + constexpr rexy::static_string joined(void){return "joined"_ss;} + constexpr rexy::static_string chunk(void){return "chunk"_ss;} + constexpr rexy::static_string newversion(void){return "new_version"_ss;} + constexpr rexy::static_string presence(void){return "presence"_ss;} + constexpr rexy::static_string displayname(void){return "displayname"_ss;} + constexpr rexy::static_string avatarurl(void){return "avatar_url"_ss;} + constexpr rexy::static_string joinedrooms(void){return "joined_rooms"_ss;} + constexpr rexy::static_string contenturi(void){return "content_uri"_ss;} + constexpr rexy::static_string name(void){return "name"_ss;} + constexpr rexy::static_string roomaliasname(void){return "room_alias_name"_ss;} + constexpr rexy::static_string typing(void){return "typing"_ss;} + constexpr rexy::static_string timeout(void){return "timeout"_ss;} + constexpr rexy::static_string session(void){return "session"_ss;} namespace event{ - constexpr raii::static_string type(void){return "type"_ss;} - constexpr raii::static_string content(void){return "content"_ss;} - constexpr raii::static_string eventid(void){return "event_id"_ss;} - constexpr raii::static_string sender(void){return "sender"_ss;} - constexpr raii::static_string origin_server_ts(void){return "origin_server_ts"_ss;} - constexpr raii::static_string roomid(void){return "room_id"_ss;} - constexpr raii::static_string extra(void){return "unsigned"_ss;} - constexpr raii::static_string state_key(void){return "state_key"_ss;} - constexpr raii::static_string prev_content(void){return "prev_content"_ss;} - constexpr raii::static_string redacts(void){return "redacts"_ss;} + constexpr rexy::static_string type(void){return "type"_ss;} + constexpr rexy::static_string content(void){return "content"_ss;} + constexpr rexy::static_string eventid(void){return "event_id"_ss;} + constexpr rexy::static_string sender(void){return "sender"_ss;} + constexpr rexy::static_string origin_server_ts(void){return "origin_server_ts"_ss;} + constexpr rexy::static_string roomid(void){return "room_id"_ss;} + constexpr rexy::static_string extra(void){return "unsigned"_ss;} + constexpr rexy::static_string state_key(void){return "state_key"_ss;} + constexpr rexy::static_string prev_content(void){return "prev_content"_ss;} + constexpr rexy::static_string redacts(void){return "redacts"_ss;} namespace contentbody{ - constexpr raii::static_string body(void){return "body"_ss;} - constexpr raii::static_string info(void){return "info"_ss;} + constexpr rexy::static_string body(void){return "body"_ss;} + constexpr rexy::static_string info(void){return "info"_ss;} namespace infobody{ - constexpr raii::static_string height(void){return "h"_ss;} - constexpr raii::static_string width(void){return "w"_ss;} - constexpr raii::static_string mimetype(void){return "mimetype"_ss;} - constexpr raii::static_string size(void){return "size"_ss;} - constexpr raii::static_string thumbinfo(void){return "thumbnail_info"_ss;} + constexpr rexy::static_string height(void){return "h"_ss;} + constexpr rexy::static_string width(void){return "w"_ss;} + constexpr rexy::static_string mimetype(void){return "mimetype"_ss;} + constexpr rexy::static_string size(void){return "size"_ss;} + constexpr rexy::static_string thumbinfo(void){return "thumbnail_info"_ss;} namespace thumbnail{ - constexpr raii::static_string height(void){return infobody::height();} - constexpr raii::static_string width(void){return infobody::width();} - constexpr raii::static_string mimetype(void){return infobody::mimetype();} - constexpr raii::static_string size(void){return infobody::size();} + constexpr rexy::static_string height(void){return infobody::height();} + constexpr rexy::static_string width(void){return infobody::width();} + constexpr rexy::static_string mimetype(void){return infobody::mimetype();} + constexpr rexy::static_string size(void){return infobody::size();} } - constexpr raii::static_string thumburl(void){return "thumbnail_url"_ss;} + constexpr rexy::static_string thumburl(void){return "thumbnail_url"_ss;} } - constexpr raii::static_string msgtype(void){return "msgtype"_ss;} - constexpr raii::static_string url(void){return "url"_ss;} + constexpr rexy::static_string msgtype(void){return "msgtype"_ss;} + constexpr rexy::static_string url(void){return "url"_ss;} } } namespace auth{ - constexpr raii::static_string type(void){return event::type();} - constexpr raii::static_string medium(void){return "medium"_ss;} - constexpr raii::static_string address(void){return "address"_ss;} - constexpr raii::static_string identifier(void){return "identifier"_ss;} - constexpr raii::static_string user(void){return "user"_ss;} - constexpr raii::static_string password(void){return "password"_ss;} - constexpr raii::static_string token(void){return "token"_ss;} - constexpr raii::static_string device_id(void){return "device_id"_ss;} - constexpr raii::static_string initial_device_display_name(void){return "initial_device_display_name"_ss;} - constexpr raii::static_string newpassword(void){return "new_password"_ss;} - constexpr raii::static_string auth(void){return "auth"_ss;} - constexpr raii::static_string userid(void){return "user_id"_ss;} - constexpr raii::static_string accesstoken(void){return "access_token"_ss;} - constexpr raii::static_string home_server(void){return "home_server"_ss;} - constexpr raii::static_string well_known(void){return "well_known"_ss;} - constexpr raii::static_string base_url(void){return "base_url"_ss;} - constexpr raii::static_string inhibit_login(void){return "inhibit_login"_ss;} + constexpr rexy::static_string type(void){return event::type();} + constexpr rexy::static_string medium(void){return "medium"_ss;} + constexpr rexy::static_string address(void){return "address"_ss;} + constexpr rexy::static_string identifier(void){return "identifier"_ss;} + constexpr rexy::static_string user(void){return "user"_ss;} + constexpr rexy::static_string password(void){return "password"_ss;} + constexpr rexy::static_string token(void){return "token"_ss;} + constexpr rexy::static_string device_id(void){return "device_id"_ss;} + constexpr rexy::static_string initial_device_display_name(void){return "initial_device_display_name"_ss;} + constexpr rexy::static_string newpassword(void){return "new_password"_ss;} + constexpr rexy::static_string auth(void){return "auth"_ss;} + constexpr rexy::static_string userid(void){return "user_id"_ss;} + constexpr rexy::static_string accesstoken(void){return "access_token"_ss;} + constexpr rexy::static_string home_server(void){return "home_server"_ss;} + constexpr rexy::static_string well_known(void){return "well_known"_ss;} + constexpr rexy::static_string base_url(void){return "base_url"_ss;} + constexpr rexy::static_string inhibit_login(void){return "inhibit_login"_ss;} namespace authbody{ - constexpr raii::static_string type(void){return auth::type();} - constexpr raii::static_string session(void){return "session"_ss;} - constexpr raii::static_string user(void){return auth::user();} - constexpr raii::static_string password(void){return auth::password();} + constexpr rexy::static_string type(void){return auth::type();} + constexpr rexy::static_string session(void){return "session"_ss;} + constexpr rexy::static_string user(void){return auth::user();} + constexpr rexy::static_string password(void){return auth::password();} } namespace identifierbody{ - constexpr raii::static_string type(void){return auth::type();} - constexpr raii::static_string medium(void){return auth::medium();} - constexpr raii::static_string address(void){return auth::address();} - constexpr raii::static_string session(void){return auth::authbody::session();} - constexpr raii::static_string user(void){return auth::authbody::user();} - constexpr raii::static_string password(void){return auth::password();} + constexpr rexy::static_string type(void){return auth::type();} + constexpr rexy::static_string medium(void){return auth::medium();} + constexpr rexy::static_string address(void){return auth::address();} + constexpr rexy::static_string session(void){return auth::authbody::session();} + constexpr rexy::static_string user(void){return auth::authbody::user();} + constexpr rexy::static_string password(void){return auth::password();} } } } @@ -99,101 +99,101 @@ namespace matrix::json{ } namespace events{ - constexpr raii::static_string homeserver(void){return "m.homeserver"_ss;} - constexpr raii::static_string identity_server(void){return "m.identity_server"_ss;} - constexpr raii::static_string presence(void){return "m.presence"_ss;} - constexpr raii::static_string direct(void){return "m.direct"_ss;} - constexpr raii::static_string ignored_user_list(void){return "m.ignored_user_list"_ss;} - constexpr raii::static_string joined_member_count(void){return "m.joined_member_count"_ss;} - constexpr raii::static_string invited_member_count(void){return "m.invited_member_count"_ss;} + constexpr rexy::static_string homeserver(void){return "m.homeserver"_ss;} + constexpr rexy::static_string identity_server(void){return "m.identity_server"_ss;} + constexpr rexy::static_string presence(void){return "m.presence"_ss;} + constexpr rexy::static_string direct(void){return "m.direct"_ss;} + constexpr rexy::static_string ignored_user_list(void){return "m.ignored_user_list"_ss;} + constexpr rexy::static_string joined_member_count(void){return "m.joined_member_count"_ss;} + constexpr rexy::static_string invited_member_count(void){return "m.invited_member_count"_ss;} namespace key{ - constexpr raii::static_string verification_request(void){return "m.key.verification.request"_ss;} - constexpr raii::static_string verification_start(void){return "m.key.verification.start"_ss;} - constexpr raii::static_string verification_cancel(void){return "m.key.verification.cancel"_ss;} - constexpr raii::static_string verification_accept(void){return "m.key.verification.accept"_ss;} - constexpr raii::static_string verification_key(void){return "m.key.verification.key"_ss;} - constexpr raii::static_string verification_mac(void){return "m.key.verification.mac"_ss;} + constexpr rexy::static_string verification_request(void){return "m.key.verification.request"_ss;} + constexpr rexy::static_string verification_start(void){return "m.key.verification.start"_ss;} + constexpr rexy::static_string verification_cancel(void){return "m.key.verification.cancel"_ss;} + constexpr rexy::static_string verification_accept(void){return "m.key.verification.accept"_ss;} + constexpr rexy::static_string verification_key(void){return "m.key.verification.key"_ss;} + constexpr rexy::static_string verification_mac(void){return "m.key.verification.mac"_ss;} } namespace login{ - constexpr raii::static_string password(void){return "m.login.password"_ss;} - constexpr raii::static_string recaptcha(void){return "m.login.recaptcha"_ss;} - constexpr raii::static_string oauth2(void){return "m.login.oauth2"_ss;} - constexpr raii::static_string email(void){return "m.login.email.identity"_ss;} - constexpr raii::static_string msisdn(void){return "m.login.msisdn"_ss;} - constexpr raii::static_string token(void){return "m.login.token"_ss;} - constexpr raii::static_string dummy(void){return "m.login.dummy"_ss;} + constexpr rexy::static_string password(void){return "m.login.password"_ss;} + constexpr rexy::static_string recaptcha(void){return "m.login.recaptcha"_ss;} + constexpr rexy::static_string oauth2(void){return "m.login.oauth2"_ss;} + constexpr rexy::static_string email(void){return "m.login.email.identity"_ss;} + constexpr rexy::static_string msisdn(void){return "m.login.msisdn"_ss;} + constexpr rexy::static_string token(void){return "m.login.token"_ss;} + constexpr rexy::static_string dummy(void){return "m.login.dummy"_ss;} } namespace id{ - constexpr raii::static_string user(void){return "m.id.user"_ss;} - constexpr raii::static_string thirdparty(void){return "m.id.thirdparty"_ss;} - constexpr raii::static_string phone(void){return "m.id.phone"_ss;} + constexpr rexy::static_string user(void){return "m.id.user"_ss;} + constexpr rexy::static_string thirdparty(void){return "m.id.thirdparty"_ss;} + constexpr rexy::static_string phone(void){return "m.id.phone"_ss;} } namespace rule{ - constexpr raii::static_string rules(void){return "m.push_rules"_ss;} - constexpr raii::static_string master(void){return ".m.rule.master"_ss;} - constexpr raii::static_string suppress_notices(void){return ".m.rule.suppress_notices"_ss;} - constexpr raii::static_string invite_for_me(void){return ".m.rule.invite_for_me"_ss;} - constexpr raii::static_string member_event(void){return ".m.rule.member_event"_ss;} - constexpr raii::static_string contains_displayname(void){return ".m.rule.contains_display_name"_ss;} - constexpr raii::static_string tombstone(void){return ".m.rule.tombstone"_ss;} - constexpr raii::static_string roomnotif(void){return ".m.rule.roomnotif"_ss;} - constexpr raii::static_string contains_username(void){return ".m.rule.contains_user_name"_ss;} - constexpr raii::static_string call(void){return ".m.rule.call"_ss;} - constexpr raii::static_string encrypted_one_to_one(void){return ".m.rule.encrypted_room_one_to_one"_ss;} - constexpr raii::static_string message(void){return ".m.rule.message"_ss;} - constexpr raii::static_string encrypted(void){return ".m.rule.encrypted"_ss;} + constexpr rexy::static_string rules(void){return "m.push_rules"_ss;} + constexpr rexy::static_string master(void){return ".m.rule.master"_ss;} + constexpr rexy::static_string suppress_notices(void){return ".m.rule.suppress_notices"_ss;} + constexpr rexy::static_string invite_for_me(void){return ".m.rule.invite_for_me"_ss;} + constexpr rexy::static_string member_event(void){return ".m.rule.member_event"_ss;} + constexpr rexy::static_string contains_displayname(void){return ".m.rule.contains_display_name"_ss;} + constexpr rexy::static_string tombstone(void){return ".m.rule.tombstone"_ss;} + constexpr rexy::static_string roomnotif(void){return ".m.rule.roomnotif"_ss;} + constexpr rexy::static_string contains_username(void){return ".m.rule.contains_user_name"_ss;} + constexpr rexy::static_string call(void){return ".m.rule.call"_ss;} + constexpr rexy::static_string encrypted_one_to_one(void){return ".m.rule.encrypted_room_one_to_one"_ss;} + constexpr rexy::static_string message(void){return ".m.rule.message"_ss;} + constexpr rexy::static_string encrypted(void){return ".m.rule.encrypted"_ss;} } namespace e2e{ - constexpr raii::static_string curve_aes_sha2(void){return "m.olm.v1.curve25519-aes-sha2"_ss;} - constexpr raii::static_string aes_sha2(void){return "m.megolm.v1.aes-sha2"_ss;} - constexpr raii::static_string encryption(void){return "m.room.encryption"_ss;} - constexpr raii::static_string key(void){return "m.room_key"_ss;} - constexpr raii::static_string key_request(void){return "m.room_key_request"_ss;} - constexpr raii::static_string forwarded_key(void){return "m.forwarded_room_key"_ss;} - constexpr raii::static_string dummy(void){return "m.dummy"_ss;} + constexpr rexy::static_string curve_aes_sha2(void){return "m.olm.v1.curve25519-aes-sha2"_ss;} + constexpr rexy::static_string aes_sha2(void){return "m.megolm.v1.aes-sha2"_ss;} + constexpr rexy::static_string encryption(void){return "m.room.encryption"_ss;} + constexpr rexy::static_string key(void){return "m.room_key"_ss;} + constexpr rexy::static_string key_request(void){return "m.room_key_request"_ss;} + constexpr rexy::static_string forwarded_key(void){return "m.forwarded_room_key"_ss;} + constexpr rexy::static_string dummy(void){return "m.dummy"_ss;} } namespace room{ - constexpr raii::static_string aliases(void){return "m.room.aliases"_ss;} - constexpr raii::static_string canonical_alias(void){return "m.room.canonical_alias"_ss;} - constexpr raii::static_string create(void){return "m.room.create"_ss;} - constexpr raii::static_string join_rules(void){return "m.room.join_rules"_ss;} - constexpr raii::static_string member(void){return "m.room.member"_ss;} - constexpr raii::static_string power_levels(void){return "m.room.power_levels"_ss;} - constexpr raii::static_string redaction(void){return "m.room.redaction"_ss;} - constexpr raii::static_string heroes(void){return "m.heroes"_ss;} - constexpr raii::static_string message(void){return "m.room.message"_ss;} - constexpr raii::static_string sticker(void){return "m.sticker"_ss;} - [[deprecated]] constexpr raii::static_string message_feedback(void){return "m.room.message.feedback"_ss;} - constexpr raii::static_string name(void){return "m.room.name"_ss;} - constexpr raii::static_string topic(void){return "m.room.topic"_ss;} - constexpr raii::static_string avatar(void){return "m.room.avatar"_ss;} - constexpr raii::static_string pinned_events(void){return "m.room.pinned_events"_ss;} - constexpr raii::static_string typing(void){return "m.typing"_ss;} - constexpr raii::static_string receipt(void){return "m.receipt"_ss;} - constexpr raii::static_string fully_read(void){return "m.fully_read"_ss;} - constexpr raii::static_string history_visibility(void){return "m.room.history_visibility"_ss;} - constexpr raii::static_string third_party_invite(void){return "m.room.third_party_invite"_ss;} - constexpr raii::static_string guest_access(void){return "m.room.guest_access"_ss;} - constexpr raii::static_string tag(void){return "m.tag"_ss;} - constexpr raii::static_string server_acl(void){return "m.room.server_acl"_ss;} + constexpr rexy::static_string aliases(void){return "m.room.aliases"_ss;} + constexpr rexy::static_string canonical_alias(void){return "m.room.canonical_alias"_ss;} + constexpr rexy::static_string create(void){return "m.room.create"_ss;} + constexpr rexy::static_string join_rules(void){return "m.room.join_rules"_ss;} + constexpr rexy::static_string member(void){return "m.room.member"_ss;} + constexpr rexy::static_string power_levels(void){return "m.room.power_levels"_ss;} + constexpr rexy::static_string redaction(void){return "m.room.redaction"_ss;} + constexpr rexy::static_string heroes(void){return "m.heroes"_ss;} + constexpr rexy::static_string message(void){return "m.room.message"_ss;} + constexpr rexy::static_string sticker(void){return "m.sticker"_ss;} + [[deprecated]] constexpr rexy::static_string message_feedback(void){return "m.room.message.feedback"_ss;} + constexpr rexy::static_string name(void){return "m.room.name"_ss;} + constexpr rexy::static_string topic(void){return "m.room.topic"_ss;} + constexpr rexy::static_string avatar(void){return "m.room.avatar"_ss;} + constexpr rexy::static_string pinned_events(void){return "m.room.pinned_events"_ss;} + constexpr rexy::static_string typing(void){return "m.typing"_ss;} + constexpr rexy::static_string receipt(void){return "m.receipt"_ss;} + constexpr rexy::static_string fully_read(void){return "m.fully_read"_ss;} + constexpr rexy::static_string history_visibility(void){return "m.room.history_visibility"_ss;} + constexpr rexy::static_string third_party_invite(void){return "m.room.third_party_invite"_ss;} + constexpr rexy::static_string guest_access(void){return "m.room.guest_access"_ss;} + constexpr rexy::static_string tag(void){return "m.tag"_ss;} + constexpr rexy::static_string server_acl(void){return "m.room.server_acl"_ss;} } namespace msgtype{ - constexpr raii::static_string text(void){return "m.text"_ss;} - constexpr raii::static_string emote(void){return "m.emote"_ss;} - constexpr raii::static_string notice(void){return "m.notice"_ss;} - constexpr raii::static_string image(void){return "m.image"_ss;} - constexpr raii::static_string file(void){return "m.file"_ss;} - constexpr raii::static_string audio(void){return "m.audio"_ss;} - constexpr raii::static_string location(void){return "m.location"_ss;} - constexpr raii::static_string video(void){return "m.video"_ss;} - constexpr raii::static_string server_notice(void){return "m.server_notice"_ss;} + constexpr rexy::static_string text(void){return "m.text"_ss;} + constexpr rexy::static_string emote(void){return "m.emote"_ss;} + constexpr rexy::static_string notice(void){return "m.notice"_ss;} + constexpr rexy::static_string image(void){return "m.image"_ss;} + constexpr rexy::static_string file(void){return "m.file"_ss;} + constexpr rexy::static_string audio(void){return "m.audio"_ss;} + constexpr rexy::static_string location(void){return "m.location"_ss;} + constexpr rexy::static_string video(void){return "m.video"_ss;} + constexpr rexy::static_string server_notice(void){return "m.server_notice"_ss;} } namespace call{ - constexpr raii::static_string invite(void){return "m.call.invite"_ss;} - constexpr raii::static_string candidates(void){return "m.call.candidates"_ss;} - constexpr raii::static_string answer(void){return "m.call.answer"_ss;} - constexpr raii::static_string hangup(void){return "m.call.hangup"_ss;} + constexpr rexy::static_string invite(void){return "m.call.invite"_ss;} + constexpr rexy::static_string candidates(void){return "m.call.candidates"_ss;} + constexpr rexy::static_string answer(void){return "m.call.answer"_ss;} + constexpr rexy::static_string hangup(void){return "m.call.hangup"_ss;} } } diff --git a/include/matrix/rest/client_url_list.hpp b/include/matrix/rest/client_url_list.hpp index 01a9928..af1f554 100644 --- a/include/matrix/rest/client_url_list.hpp +++ b/include/matrix/rest/client_url_list.hpp @@ -20,18 +20,18 @@ #define MATRIX_REST_CLIENT_URL_LIST_HPP #include "matrix/session_info.hpp" -#include "raii/string.hpp" +#include #include "matrix/rest/urls_common.hpp" namespace matrix::rest{ class client_url_list { private: - raii::string m_create_room; - raii::string m_file_upload; - raii::string m_room_list; - raii::string m_alias_lookup; - raii::string m_profile_picture; + rexy::string m_create_room; + rexy::string m_file_upload; + rexy::string m_room_list; + rexy::string m_alias_lookup; + rexy::string m_profile_picture; public: client_url_list(void) = default; @@ -41,22 +41,22 @@ namespace matrix::rest{ client_url_list& operator=(const client_url_list&) = default; client_url_list& operator=(client_url_list&&) = default; - const raii::string& create_room(void)const; - const raii::string& file_upload(void)const; - const raii::string& room_list(void)const; - const raii::string& alias_lookup(void)const; - const raii::string& profile_picture(void)const; - raii::string displayname(const session_info& session, const raii::string_base& userid)const; - raii::string file_download(const session_info& session, const raii::string_base& mediaid); - raii::string file_thumbnail(const session_info& session, const raii::string_base& fileurl, int width, int height, const raii::string_base& method)const; - raii::string presence(const session_info& session, const raii::string_base& userid)const; - raii::string sync(const session_info& session, const raii::rjp_string& batch, const raii::string& timeout); + const rexy::string& create_room(void)const; + const rexy::string& file_upload(void)const; + const rexy::string& room_list(void)const; + const rexy::string& alias_lookup(void)const; + const rexy::string& profile_picture(void)const; + rexy::string displayname(const session_info& session, const rexy::string_base& userid)const; + rexy::string file_download(const session_info& session, const rexy::string_base& mediaid); + rexy::string file_thumbnail(const session_info& session, const rexy::string_base& fileurl, int width, int height, const rexy::string_base& method)const; + rexy::string presence(const session_info& session, const rexy::string_base& userid)const; + rexy::string sync(const session_info& session, const raii::rjp_string& batch, const rexy::string& timeout); void repopulate(const session_info&); void invalidate(void); private: - static raii::string get_server_media_string(const raii::string_base& url); + static rexy::string get_server_media_string(const rexy::string_base& url); }; } diff --git a/include/matrix/rest/room_url_list.hpp b/include/matrix/rest/room_url_list.hpp index 62e1de3..3581a39 100644 --- a/include/matrix/rest/room_url_list.hpp +++ b/include/matrix/rest/room_url_list.hpp @@ -19,7 +19,7 @@ #ifndef MATRIX_ROOM_URL_LIST_HPP #define MATRIX_ROOM_URL_LIST_HPP -#include "raii/string.hpp" +#include #include "matrix/session_info.hpp" namespace matrix{ @@ -27,35 +27,35 @@ namespace matrix{ class room_url_list { private: - raii::string m_typing; - raii::string m_kick; - raii::string m_ban; - raii::string m_unban; - raii::string m_invite; - raii::string m_members; + rexy::string m_typing; + rexy::string m_kick; + rexy::string m_ban; + rexy::string m_unban; + rexy::string m_invite; + rexy::string m_members; public: - room_url_list(const session_info& session, const raii::string_base& roomid); - raii::string join(const session_info& session, const raii::string_base& roomid)const; - raii::string leave(const session_info& session, const raii::string_base& roomid)const; - raii::string forget(const session_info& session, const raii::string_base& roomid)const; - raii::string upgrade(const session_info& session, const raii::string_base& roomid)const; - raii::string read_receipt(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const; - raii::string send(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventtype)const; - raii::string redact(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const; - raii::string event(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const; - const raii::string& typing(void)const; - const raii::string& kick(void)const; - const raii::string& ban(void)const; - const raii::string& unban(void)const; - const raii::string& invite(void)const; - const raii::string& room_members(void)const; - raii::string messages(const session_info& session, const raii::string_base& roomid, - const raii::string_base& from, const raii::string_base& to, - const raii::string_base& dir, int limit)const; + room_url_list(const session_info& session, const rexy::string_base& roomid); + rexy::string join(const session_info& session, const rexy::string_base& roomid)const; + rexy::string leave(const session_info& session, const rexy::string_base& roomid)const; + rexy::string forget(const session_info& session, const rexy::string_base& roomid)const; + rexy::string upgrade(const session_info& session, const rexy::string_base& roomid)const; + rexy::string read_receipt(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const; + rexy::string send(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventtype)const; + rexy::string redact(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const; + rexy::string event(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const; + const rexy::string& typing(void)const; + const rexy::string& kick(void)const; + const rexy::string& ban(void)const; + const rexy::string& unban(void)const; + const rexy::string& invite(void)const; + const rexy::string& room_members(void)const; + rexy::string messages(const session_info& session, const rexy::string_base& roomid, + const rexy::string_base& from, const rexy::string_base& to, + const rexy::string_base& dir, int limit)const; - raii::string power_level(const session_info& session, const raii::string_base& roomid)const; + rexy::string power_level(const session_info& session, const rexy::string_base& roomid)const; - void repopulate(const session_info& session, const raii::string_base& roomid); + void repopulate(const session_info& session, const rexy::string_base& roomid); void invalidate_accesstoken(void); private: static constexpr const char* s_proto = "https://"; diff --git a/include/matrix/rest/session_urls.hpp b/include/matrix/rest/session_urls.hpp index ec84c35..f021313 100644 --- a/include/matrix/rest/session_urls.hpp +++ b/include/matrix/rest/session_urls.hpp @@ -21,13 +21,13 @@ #include "matrix/rest/urls_common.hpp" #include "matrix/session_info.hpp" -#include "raii/string.hpp" +#include namespace matrix::rest::session_urls{ - raii::string login(const session_info&); - raii::string logout(const session_info&); - raii::string password(const session_info&); - raii::string whoami(const session_info&); + rexy::string login(const session_info&); + rexy::string logout(const session_info&); + rexy::string password(const session_info&); + rexy::string whoami(const session_info&); } #endif diff --git a/include/matrix/rest/urls_common.hpp b/include/matrix/rest/urls_common.hpp index d13e425..ee392ca 100644 --- a/include/matrix/rest/urls_common.hpp +++ b/include/matrix/rest/urls_common.hpp @@ -19,13 +19,13 @@ #ifndef MATRIX_REST_URLS_COMMON_HPP #define MATRIX_REST_URLS_COMMON_HPP -#include "raii/string_base.hpp" +#include namespace matrix::rest{ - constexpr raii::static_string proto(void){ + constexpr rexy::static_string proto(void){ return "https://"_ss; } - constexpr raii::static_string revision(void){ + constexpr rexy::static_string revision(void){ return "r0"_ss; } } diff --git a/include/matrix/roomcxn.hpp b/include/matrix/roomcxn.hpp index 9ea05f4..ca8c04a 100644 --- a/include/matrix/roomcxn.hpp +++ b/include/matrix/roomcxn.hpp @@ -21,7 +21,7 @@ #include "matrix/connection.hpp" #include "matrix/upload_info.hpp" -#include "raii/string.hpp" +#include #include "raii/rjp_string.hpp" #include "matrix/rest/room_url_list.hpp" #include "matrix/iterable.hpp" @@ -34,12 +34,12 @@ namespace matrix{ class roomcxn : public connection { private: - raii::string m_roomid; + rexy::string m_roomid; room_url_list m_urls; public: - roomcxn(const std::shared_ptr&, const raii::string_base& roomid); - roomcxn(const std::shared_ptr& ses, raii::string&& roomid); + roomcxn(const std::shared_ptr&, const rexy::string_base& roomid); + roomcxn(const std::shared_ptr& ses, rexy::string&& roomid); roomcxn(const roomcxn&) = default; roomcxn(roomcxn&&) = default; @@ -59,42 +59,42 @@ namespace matrix{ netreturn> members(void)const; //member management - netreturn invite(const raii::string_base& userid); + netreturn invite(const rexy::string_base& userid); [[deprecated("Use roomcxn::kick instead")]] - netreturn uninvite(const raii::string_base& userid, const raii::string_base& reason = raii::string()); - netreturn kick(const raii::string_base& userid, const raii::string_base& reason = raii::string()); - netreturn ban(const raii::string_base& userid, const raii::string_base& reason = raii::string()); - netreturn unban(const raii::string_base& userid); + netreturn uninvite(const rexy::string_base& userid, const rexy::string_base& reason = rexy::string()); + netreturn kick(const rexy::string_base& userid, const rexy::string_base& reason = rexy::string()); + netreturn ban(const rexy::string_base& userid, const rexy::string_base& reason = rexy::string()); + netreturn unban(const rexy::string_base& userid); //sending events - netreturn send_custom_event(const raii::string_base& event, const raii::string_base& eventtype)const; - netreturn send_message(const raii::string_base& text)const; - netreturn send_notice(const raii::string_base& text)const; + netreturn send_custom_event(const rexy::string_base& event, const rexy::string_base& eventtype)const; + netreturn send_message(const rexy::string_base& text)const; + netreturn send_notice(const rexy::string_base& text)const; netreturn send_file(const uploaded_file& file)const; netreturn send_image(const uploaded_image& image)const; netreturn send_video(const uploaded_video& video)const; netreturn send_audio(const uploaded_audio& audio)const; netreturn forward_event(const sync::room_event&)const; netreturn send_typing(bool active, int timeout = 5000)const; - netreturn send_read_receipt(const raii::string_base& eventid)const; + netreturn send_read_receipt(const rexy::string_base& eventid)const; - netreturn get_event(const raii::string_base& eventid)const; - netreturn redact_event(const raii::string_base& eventid, const raii::string_base& reason)const; - netreturn redact_event(const raii::string_base& eventid)const; + netreturn get_event(const rexy::string_base& eventid)const; + netreturn redact_event(const rexy::string_base& eventid, const rexy::string_base& reason)const; + netreturn redact_event(const rexy::string_base& eventid)const; //recieve events netreturn get_events_forward(int amount); netreturn get_events_backward(int amount); - netreturn get_events_forward(int amount, const raii::string_base& from, const raii::string_base& to); - netreturn get_events_backward(int amount, const raii::string_base& from, const raii::string_base& to); + netreturn get_events_forward(int amount, const rexy::string_base& from, const rexy::string_base& to); + netreturn get_events_backward(int amount, const rexy::string_base& from, const rexy::string_base& to); //meta stuff void regenerate_urls(void); netreturn upgrade(int version)const; private: - netreturn _get_events(int amount, raii::static_string direction, const raii::string_base& from, const raii::string_base& to); - netreturn _send_message(const raii::string_base& msg)const; + netreturn _get_events(int amount, rexy::static_string direction, const rexy::string_base& from, const rexy::string_base& to); + netreturn _send_message(const rexy::string_base& msg)const; }; } diff --git a/include/matrix/session.hpp b/include/matrix/session.hpp index 2d7f6a9..743ef54 100644 --- a/include/matrix/session.hpp +++ b/include/matrix/session.hpp @@ -23,7 +23,7 @@ #include "matrix/session_info.hpp" #include "matrix/auth.hpp" #include "raii/curler.hpp" -#include "raii/string.hpp" +#include #include "matrix/connection.hpp" #include //pair @@ -64,8 +64,8 @@ namespace matrix{ * NOT thread safe. * Set the useragent for the session and all spawned clients and syncers. */ - void set_useragent(const raii::string_base&); - void set_useragent(raii::string&&); + void set_useragent(const rexy::string_base&); + void set_useragent(rexy::string&&); /* @@ -73,15 +73,15 @@ namespace matrix{ * Set the access token for the session and all spawned clients and syncers. * Note this will not check if the access token is valid or not, nor will urls be updated. */ - void set_access_token(const raii::string_base&); - void set_access_token(raii::string&&); + void set_access_token(const rexy::string_base&); + void set_access_token(rexy::string&&); /* * NOT thread safe. * Set the homeserver for the session and all spawned clients and syncers. * Note this will not check if the homeserver is valid or not, nor will urs be updated. */ - void set_homeserver(const raii::string_base&); - void set_homeserver(raii::string&&); + void set_homeserver(const rexy::string_base&); + void set_homeserver(rexy::string&&); /* * NOT thread safe. @@ -97,7 +97,7 @@ namespace matrix{ * homeserver are valid. * Returns: true if success, false otherwise. */ - netreturn login(const raii::string_base& username, const raii::string_base& pass); + netreturn login(const rexy::string_base& username, const rexy::string_base& pass); /* * Logout of the current connection to the homeserver. Will invalidate the access token on the server side. @@ -110,7 +110,7 @@ namespace matrix{ bool valid(void)const; - netreturn change_password(const raii::string_base& oldpass, const raii::string_base& newpass); + netreturn change_password(const rexy::string_base& oldpass, const rexy::string_base& newpass); /* * Create a matrix::client which shares login details with this session. * Note the client and session will share memory for generated urls, homeserver, access_token, and @@ -127,11 +127,11 @@ namespace matrix{ */ void invalidate(void); private: - netreturn _do_login(const raii::string_base& username, const raii::string_base& pass); + netreturn _do_login(const rexy::string_base& username, const rexy::string_base& pass); void _populate_session_info(const auth_data& a); netreturn _get_userid(void); - raii::string _request_access_token(const raii::string_base& name, const raii::string_base& pass, const raii::string_base& loginurl)const; - netreturn> _get_new_access_token(const raii::string_base& name, const raii::string_base& pass, const raii::string_base& loginurl); + rexy::string _request_access_token(const rexy::string_base& name, const rexy::string_base& pass, const rexy::string_base& loginurl)const; + netreturn> _get_new_access_token(const rexy::string_base& name, const rexy::string_base& pass, const rexy::string_base& loginurl); }; } diff --git a/include/matrix/session_info.hpp b/include/matrix/session_info.hpp index e4a2295..dda6a82 100644 --- a/include/matrix/session_info.hpp +++ b/include/matrix/session_info.hpp @@ -19,15 +19,15 @@ #ifndef MATRIX_SESSION_INFO_HPP #define MATRIX_SESSION_INFO_HPP -#include "raii/string.hpp" +#include #include "raii/rjp_string.hpp" namespace matrix{ struct session_info{ - raii::string useragent; //useragent to identify our application - raii::string homeserver; //name of our homeserver + rexy::string useragent; //useragent to identify our application + rexy::string homeserver; //name of our homeserver raii::rjp_string access_token; //authentication - raii::string auth_header; + rexy::string auth_header; raii::rjp_string userid; //userid including homeserver }; } diff --git a/include/matrix/sync_response.hpp b/include/matrix/sync_response.hpp index 8f5e3aa..065f6fb 100644 --- a/include/matrix/sync_response.hpp +++ b/include/matrix/sync_response.hpp @@ -19,7 +19,7 @@ #ifndef SYNC_RESPONSE_HPP #define SYNC_RESPONSE_HPP -#include "raii/string_base.hpp" +#include #include "raii/rjp_string.hpp" #include "raii/rjp_iterator.hpp" #include "raii/rjp_ptr.hpp" @@ -38,7 +38,7 @@ namespace matrix::sync{ RJP_value* m_room; public: constexpr room_event_response(RJP_value* room):m_room(room){} - raii::static_string roomid(void)const; + rexy::static_string roomid(void)const; room_event_list account_events(void); room_ephem_event_list ephemeral_events(void); room_state_event_list state_events(void); @@ -129,7 +129,7 @@ namespace matrix::sync{ raii::rjp_ptr m_root = nullptr; public: constexpr client_response(void) = default; - client_response(const raii::string_base& src); + client_response(const rexy::string_base& src); client_response(RJP_value* root); room_list room_join_events(void)const; @@ -137,7 +137,7 @@ namespace matrix::sync{ room_list room_leave_events(void)const; device_list device_lists(void)const; - raii::static_string next_batch(void)const&; + rexy::static_string next_batch(void)const&; raii::rjp_string next_batch(void)&&; event_list to_device_events(void)const; diff --git a/include/matrix/upload_info.hpp b/include/matrix/upload_info.hpp index 57a8082..dcc4d04 100644 --- a/include/matrix/upload_info.hpp +++ b/include/matrix/upload_info.hpp @@ -20,8 +20,8 @@ #define MATRIX_UPLOAD_INFO_HPP #include "raii/rjp_string.hpp" -#include "raii/string.hpp" -#include "raii/binary.hpp" +#include +#include #include //size_t namespace matrix{ @@ -29,16 +29,16 @@ namespace matrix{ class client; struct file_details{ - raii::binary data; - raii::string name; + rexy::binary data; + rexy::string name; }; struct image_details : public file_details{ int width, height; - raii::string mimetype; + rexy::string mimetype; }; struct video_details : public image_details{}; struct audio_details : public file_details{ - raii::string mimetype; + rexy::string mimetype; }; class uploaded_file @@ -46,8 +46,8 @@ namespace matrix{ friend class matrix::client; protected: raii::rjp_string m_fileurl = {}; - raii::string m_filename = {}; - raii::string m_mimetype = {}; + rexy::string m_filename = {}; + rexy::string m_mimetype = {}; size_t m_filesize = 0; public: @@ -61,8 +61,8 @@ namespace matrix{ constexpr operator bool(void)const{return m_fileurl;} - const raii::string& mimetype(void)const{return m_mimetype;} - const raii::string& name(void)const{return m_filename;} + const rexy::string& mimetype(void)const{return m_mimetype;} + const rexy::string& name(void)const{return m_filename;} const raii::rjp_string& url(void)const{return m_fileurl;} constexpr size_t size(void)const{return m_filesize;} }; @@ -72,7 +72,7 @@ namespace matrix{ friend class matrix::client; protected: raii::rjp_string m_url; - raii::string m_mimetype; + rexy::string m_mimetype; size_t m_width = 0; size_t m_height = 0; size_t m_size = 0; @@ -92,7 +92,7 @@ namespace matrix{ constexpr size_t height(void)const{return m_height;} constexpr size_t size(void)const{return m_size;} const raii::rjp_string& url(void)const{return m_url;} - const raii::string& mimetype(void)const{return m_mimetype;} + const rexy::string& mimetype(void)const{return m_mimetype;} }; class uploaded_image : public uploaded_file { diff --git a/include/raii/binary.hpp b/include/raii/binary.hpp deleted file mode 100644 index acb3e61..0000000 --- a/include/raii/binary.hpp +++ /dev/null @@ -1,172 +0,0 @@ -/** - This file is a part of rexy's matrix client - Copyright (C) 2019-2020 rexy712 - - This program 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. - - This program 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 this program. If not, see . -*/ - -#ifndef RAII_BINARY_HPP -#define RAII_BINARY_HPP - -#include //size_t -#include //move -#include //memcpy -#include //max -#include -#include -#include "raii/default_allocator.hpp" - -namespace raii{ - - class binary_base - { - protected: - char* m_data = nullptr; - size_t m_size = 0; - size_t m_cap = 0; - public: - protected: - constexpr binary_base(void) = default; - constexpr binary_base(char* data, size_t size): - m_data(data), m_cap(size){} - constexpr binary_base(char* data, size_t cap, size_t size): - m_data(data), m_size(size), m_cap(cap){} - template - binary_base(const binary_base& b): - m_data(Allocator::copy(b.m_data, b.m_cap)), - m_size(b.m_size), - m_cap(b.m_cap){} - binary_base(binary_base&&); - ~binary_base(void) = default; - - public: - char* release(void); - - constexpr size_t size(void)const{return m_size;} - constexpr size_t capacity(void)const{return m_cap;} - constexpr char* get(void){return m_data;} - constexpr const char* get(void)const{return m_data;} - constexpr operator bool(void)const{return m_data;} - - char& operator[](size_t i); - const char& operator[](size_t i)const; - - }; - template> - class binary_data : public binary_base - { - public: - using allocator_type = Allocator; - public: - constexpr binary_data(void) = default; - binary_data(char* data, size_t size): - binary_base(data, size){} - binary_data(const char* data, size_t size): - binary_base(reinterpret_cast(Allocator::copy(data, size)), size){} - binary_data(char* data, size_t cap, size_t size): - binary_base(data, cap, size){} - binary_data(const char* data, size_t cap, size_t size): - binary_base(reinterpret_cast(Allocator::copy(data, size)), cap, size){} - binary_data(size_t size): - binary_base(reinterpret_cast(Allocator::allocate(size)), size){} - binary_data(const binary_data& b): - binary_base(b) - { - m_data = Allocator::copy(b.m_data, b.m_cap); - } - binary_data(binary_data&& b): - binary_base(std::move(b)){} - ~binary_data(void){ - Allocator::free(m_data); - } - binary_data& operator=(const binary_data& b){ - binary_data tmp(b); - return (*this = std::move(tmp)); - } - binary_data& operator=(binary_data&& b){ - m_size = b.m_size; - m_cap = b.m_cap; - std::swap(m_data, b.m_data); - return *this; - } - void reset(void){ - Allocator::free(m_data); - m_data = nullptr; - m_cap = m_size = 0; - } - void reset(char* val, size_t cap, size_t size = 0){ - Allocator::free(m_data); - m_data = val; - m_cap = cap; - m_size = size; - } - bool resize(size_t newsize){ - if(newsize < m_cap) - return false; - binary_data tmp(newsize); - if(!tmp) - return false; - memcpy(tmp.m_data, m_data, m_size); - std::swap(m_data, tmp.m_data); - m_cap = tmp.m_cap; - return true; - } - void append(const char* data, size_t len){ - if(m_size + len > m_cap) - resize(std::max(m_cap*2, m_size+len)); - memcpy(m_data+m_size, data, len); - m_size += len; - } - }; - using binary = binary_data<>; - - namespace detail{ - std::true_type is_binary_type_helper(binary_base); - std::false_type is_binary_type_helper(...); - - template - struct is_binary_type{ - constexpr static bool value = std::is_same::type>())),std::true_type>::value; - }; - } - -} - -template::value && raii::detail::is_binary_type::value,void>::type* = nullptr> -bool operator==(Left&& l, Right&& r){ - return l && r && l.size() == r.size() && l.capacity() == r.capacity() && !memcmp(l.get(), r.get(), l.size()); -} -template::value && raii::detail::is_binary_type::value,void>::type* = nullptr> -bool operator!=(Left&& l, Right&& r){ - return !(std::forward(l) == std::forward(r)); -} -template -auto operator+(const raii::binary_data& l, const raii::binary_data& r){ - raii::binary_data retval(l.size() + r.size()); - memcpy(retval.get(), l.get(), l.size()); - memcpy(retval.get()+l.size(), r.get(), r.size()); - return retval; -} -template -decltype(auto) operator+=(raii::binary_data& l, const raii::binary_data& r){ - l.resize(l.size() + r.size()); - memcpy(l.get()+l.size(), r.get(), r.size()); - return l; -} - -#ifdef RAII_STRING_BASE_HPP -#include "raii/binary_string_conv.hpp" -#endif - -#endif diff --git a/include/raii/binary_string_conv.hpp b/include/raii/binary_string_conv.hpp deleted file mode 100644 index db75d33..0000000 --- a/include/raii/binary_string_conv.hpp +++ /dev/null @@ -1,71 +0,0 @@ -/** - This file is a part of rexy's matrix client - Copyright (C) 2019-2020 rexy712 - - This program 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. - - This program 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 this program. If not, see . -*/ - -#ifndef RAII_BINARY_STRING_CONV_HPP -#define RAII_BINARY_STRING_CONV_HPP - -#include "raii/string.hpp" -#include "raii/binary.hpp" - -namespace raii{ - template::value,void>::type* = nullptr> - auto binary_to_string(const binary_data& b){ - Str s(b.size()+1); - memcpy(s.get(), b.get(), b.size()); - s[b.size()] = 0; - return s; - } - template::value && std::is_same::type,typename Str::allocator_type>::value,void>::type* = nullptr> - auto binary_to_string(binary_data&& b){ - Str s; - s.reset(b.get(), b.size()); - b.release(); - return s; - } - template::value,void>::type* = nullptr> - auto string_to_binary(const string_base& s){ - Bin b(s.length()+1); - b.append(s.get(), s.length()+1); - return b; - } - template::value && std::is_same::type,typename Bin::allocator_type>::value,void>::type* = nullptr> - auto string_to_binary(string_intermediary&& s){ - Bin b; - b.reset(s.get(), s.length()+1); - s.release(); - return b; - } -} -template::value && raii::detail::is_concrete_string::value,void>::type* = nullptr> -decltype(auto) operator+=(L& l, R&& r){ - l.append(r.get(), r.length()+1); - return l; -} -template::value && raii::detail::is_string::value && !raii::detail::is_concrete_string::value,void>::type* = nullptr> -decltype(auto) operator+=(L& l, R&& r){ - raii::string concrete = r; - return (l = concrete); -} -template::value && raii::detail::is_binary_type::value,void>::type* = nullptr> -decltype(auto) operator+=(L& l, R&& r){ - l.resize(l.length(), r.size() + 1); - memcpy(l.get()+l.length()+1, r.get(), r.size()); - return l; -} - -#endif diff --git a/include/raii/curl_string.hpp b/include/raii/curl_string.hpp index ef1cb05..92ccc14 100644 --- a/include/raii/curl_string.hpp +++ b/include/raii/curl_string.hpp @@ -19,7 +19,7 @@ #ifndef RAII_CURL_STRING_HPP #define RAII_CURL_STRING_HPP -#include "raii/string_base.hpp" +#include #include #include //size_t @@ -41,7 +41,7 @@ namespace raii{ } - using curl_string = string_intermediary; + using curl_string = rexy::string_intermediary; } diff --git a/include/raii/curler.hpp b/include/raii/curler.hpp index 0d05a1d..ae9d272 100644 --- a/include/raii/curler.hpp +++ b/include/raii/curler.hpp @@ -54,13 +54,13 @@ namespace raii{ curler& getreq(void); curler& setheader(const curl_llist& h); curler& seturl(const char* s); - curler& seturl(const string_base& s); + curler& seturl(const rexy::string_base& s); curler& setuseragent(const char* s); - curler& setuseragent(const string_base& s); + curler& setuseragent(const rexy::string_base& s); curler& setuserpwd(const char* s); - curler& setuserpwd(const string_base& s); + curler& setuserpwd(const rexy::string_base& s); curler& setpostdata(const char* s, curl_off_t len = -1); - curler& setpostdata(const string_base& s); + curler& setpostdata(const rexy::string_base& s); curler& forcessl(long version = CURL_SSLVERSION_DEFAULT); curler& setwritefun(write_function); curler& setwritedata(void*); diff --git a/include/raii/default_allocator.hpp b/include/raii/default_allocator.hpp deleted file mode 100644 index 6a7c6d2..0000000 --- a/include/raii/default_allocator.hpp +++ /dev/null @@ -1,48 +0,0 @@ -/** - This file is a part of rexy's matrix client - Copyright (C) 2019-2020 rexy712 - - This program 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. - - This program 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 this program. If not, see . -*/ - -#ifndef RAII_DEFAULT_ALLOCATOR_HPP -#define RAII_DEFAULT_ALLOCATOR_HPP - -#include //size_t -#include //memcpy -#include - -namespace raii{ - - namespace detail{ - - template - struct default_allocator - { - static void free(void* data){ - ::operator delete(data, std::align_val_t{Alignment}); - } - static void* allocate(size_t size){ - return ::operator new(size, std::align_val_t{Alignment}); - } - static void* copy(const void* c, size_t size){ - char* tmp = reinterpret_cast(allocate(size)); - memcpy(tmp, c, size); - return tmp; - } - }; - } -} - -#endif diff --git a/include/raii/filerd.hpp b/include/raii/filerd.hpp deleted file mode 100644 index 1a6e55c..0000000 --- a/include/raii/filerd.hpp +++ /dev/null @@ -1,68 +0,0 @@ -/** - This file is a part of rexy's matrix client - Copyright (C) 2019-2020 rexy712 - - This program 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. - - This program 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 this program. If not, see . -*/ - -#ifndef RAII_FILERD_HPP -#define RAII_FILERD_HPP - -#include //FILE -#include //size_t - -#include "raii/string.hpp" -#include "raii/binary.hpp" - -namespace raii{ - - //RAII wrapper for FILE* - class filerd - { - private: - FILE* m_fp = nullptr; - - public: - filerd(void) = default; - filerd(const char* f, const char* mode = "r"); - filerd(const filerd&) = delete; - filerd(filerd&& f); - ~filerd(void); - filerd& operator=(const filerd&) = delete; - filerd& operator=(filerd&& f); - - void reset(FILE* fp = nullptr); - FILE* release(void); - size_t length(void); - size_t position(void)const; - void rewind(size_t pos = 0); - - operator FILE*(void); - operator const FILE*(void)const; - FILE* get(void); - const FILE* get(void)const; - operator bool(void)const; - - size_t read(char* dest, size_t bytes); - raii::string read(size_t bytes); - raii::string readln(size_t max = 0); - raii::binary read_bin(size_t bytes); - - size_t write(const char* c, size_t bytes); - size_t write(const raii::string_base&); - }; - -} - -#endif diff --git a/include/raii/rjp_iterator.hpp b/include/raii/rjp_iterator.hpp index a2cc165..a532e0a 100644 --- a/include/raii/rjp_iterator.hpp +++ b/include/raii/rjp_iterator.hpp @@ -43,7 +43,7 @@ namespace raii{ m_root(std::exchange(e.m_root, nullptr)), m_obj(e.m_obj) { - e.m_obj = RJP_object_iterator{0}; + e.m_obj = {}; } rjp_object_iterator& operator=(rjp_object_iterator&& e){ std::swap(m_root, e.m_root); diff --git a/include/raii/rjp_string.hpp b/include/raii/rjp_string.hpp index 8bee1ab..4079657 100644 --- a/include/raii/rjp_string.hpp +++ b/include/raii/rjp_string.hpp @@ -20,7 +20,7 @@ #define RAII_RJP_STRING_HPP #include -#include "raii/string_base.hpp" +#include #include //exchange #include //memcpy @@ -39,16 +39,16 @@ namespace raii{ } //rjp allocated string - struct rjp_string : public string_intermediary + struct rjp_string : public rexy::string_intermediary { rjp_string(const rjp_string&) = default; rjp_string(rjp_string&&) = default; rjp_string& operator=(const rjp_string&) = default; rjp_string& operator=(rjp_string&&) = default; - using string_intermediary::string_intermediary; + using rexy::string_intermediary::string_intermediary; rjp_string(RJP_value* r): - string_intermediary(r ? rjp_get_string(r)->value : nullptr, + rexy::string_intermediary(r ? rjp_get_string(r)->value : nullptr, r ? rjp_get_string(r)->length : 0, r ? rjp_get_string(r)->length : 0) { @@ -59,7 +59,7 @@ namespace raii{ rjp_set_null(r); } } - using string_intermediary::operator=; + using rexy::string_intermediary::operator=; rjp_string& operator=(RJP_value* r){ if(!r) return *this; diff --git a/include/raii/string.hpp b/include/raii/string.hpp deleted file mode 100644 index e1cf707..0000000 --- a/include/raii/string.hpp +++ /dev/null @@ -1,32 +0,0 @@ -/** - This file is a part of rexy's matrix client - Copyright (C) 2019-2020 rexy712 - - This program 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. - - This program 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 this program. If not, see . -*/ - -#ifndef RAII_STRING_HPP -#define RAII_STRING_HPP - -#include "raii/string_base.hpp" -#include "raii/default_allocator.hpp" - -namespace raii{ - - //new allocated string - using string = string_intermediary>; - -} - -#endif diff --git a/include/raii/string_base.hpp b/include/raii/string_base.hpp deleted file mode 100644 index 06122bf..0000000 --- a/include/raii/string_base.hpp +++ /dev/null @@ -1,294 +0,0 @@ -/** - This file is a part of rexy's matrix client - Copyright (C) 2019-2020 rexy712 - - This program 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. - - This program 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 this program. If not, see . -*/ - -#ifndef RAII_STRING_BASE_HPP -#define RAII_STRING_BASE_HPP - -#include //is_same, integral_contant, enable_if, etc -#include //forward -#include //size_t - -namespace raii{ - - class string_expr{}; - - //Base of all RAII strings. Its use is allowing passing of raii strings to functions without knowing the exact type - class string_base : public string_expr - { - protected: - size_t m_length = 0; - size_t m_cap = 0; - char* m_data = nullptr; - - protected: - constexpr string_base(void) = default; - constexpr string_base(size_t len): - m_cap(len){} - //Initialize without copying - constexpr string_base(char* data, size_t len): - m_cap(len), m_data(data){} - constexpr string_base(char* data, size_t len, size_t cap): - m_length(len), m_cap(cap), m_data(data){} - //Copy ctor (do nothing) - string_base(const string_base&){} - ~string_base(void) = default; - - public: - //Stop managing stored pointer. Does not free. - char* release(void); - - //Length of string not including null terminator - constexpr size_t length(void)const{return m_length;} - constexpr size_t capacity(void)const{return m_cap;} - //direct access to managed pointer - constexpr char* get(void){return m_data;} - constexpr const char* get(void)const{return m_data;} - constexpr operator char*(void){return m_data;} - constexpr operator const char*(void)const{return m_data;} - //true if m_data is not null - constexpr operator bool(void)const{return m_data;} - - char& operator[](size_t i); - const char& operator[](size_t i)const; - }; - - - //Supplies all functions that string_base can't implement - template - class string_intermediary : public string_base - { - public: - using allocator_type = Allocator; - - public: - string_intermediary(void) = default; - string_intermediary(char* data, size_t len); - string_intermediary(const char* data, size_t len); - string_intermediary(char* data, size_t len, size_t cap); - string_intermediary(const char* data); - string_intermediary(size_t len); - string_intermediary(size_t len, size_t cap); - - //normal copy and move ctors - string_intermediary(const string_intermediary& b); - string_intermediary(string_intermediary&& s); - - string_intermediary(const string_base& b); - - //dtor - ~string_intermediary(void); - - string_intermediary& operator=(const string_intermediary& s); - string_intermediary& operator=(string_intermediary&& s); - //Copy from c string - string_intermediary& operator=(const char* c); - //Copy from other string_base - string_intermediary& operator=(const string_base& s); - - //Replace managed pointer. Frees existing value - void reset(char* val = nullptr); - void reset(char* val, size_t len); - bool resize(size_t newsize); - void append(const char* data, size_t len); - void append(const char* data); - void append(const string_base& s); - - private: - string_intermediary& _copy_string(const char* s, size_t len); - }; - - //Like an expression template but not really - template - class string_cat_expr : public string_expr - { - private: - Left m_l; - Right m_r; - - public: - template - constexpr string_cat_expr(T&& l, U&& r); - constexpr string_cat_expr(const string_cat_expr& s); - constexpr string_cat_expr(string_cat_expr&& s); - - constexpr size_t length(void)const; - template - operator string_intermediary(void); - constexpr const Left& left(void)const; - constexpr const Right& right(void)const; - }; - - class static_string : public string_base - { - public: - constexpr static_string(void) = default; - template - constexpr static_string(const char(&str)[N]); - constexpr static_string(const char* str, size_t len); - static_string(const char* c); - constexpr static_string(const static_string& s); - constexpr static_string(static_string&& s); - ~static_string(void) = default; - - static_string& operator=(const char* c); - static_string& operator=(const static_string& s); - static_string& operator=(static_string&&) = delete; - }; - - - namespace detail{ - std::true_type is_string_helper(string_expr); - std::false_type is_string_helper(...); - template - struct is_string{ - static constexpr bool value = std::is_same()))>::value; - }; - std::true_type is_string_base(string_base*); - std::false_type is_string_base(...); - template - struct is_concrete_string{ - static constexpr bool value = std::is_same::type*>()))>::value; - }; - template - std::true_type is_tuple_helper(std::tuple); - std::false_type is_tuple_helper(...); - template - struct is_tuple{ - static constexpr bool value = std::is_same()))>::value; - }; - - //check for member function 'length' - template - struct has_len{ - template - struct check; - - template - static std::true_type test(check*); - template - static std::false_type test(...); - - static constexpr bool value = std::is_same(0))>::value; - }; - template - struct appender - { - private: - Targ& m_targ; - public: - appender(Targ& t); - template - void operator()(const string_cat_expr& str); - void operator()(const string_base& str); - }; - } -} - -#include "raii/string_base.tpp" - -namespace{ - constexpr inline raii::static_string operator"" _ss(const char* str, size_t len){ - return raii::static_string(str, len); - } -} -template::value&&raii::detail::is_concrete_string::value,void>::type* = nullptr> -bool operator==(Str1&& left, Str2&& right){ - return left && right && left.length() == right.length() && !strcmp(left.get(), right.get()); -} -template::value&&raii::detail::is_concrete_string::value,void>::type* = nullptr> -bool operator!=(Str1&& left, Str2&& right){ - return !(left == right); -} - -template::value && std::is_rvalue_reference::value,void>::type* = nullptr> -constexpr auto operator+(const char* left, Right&& right){ - return raii::string_cat_expr::type>(raii::static_string(left), std::move(right)); -} -template::value && !std::is_rvalue_reference::value,void>::type* = nullptr> -constexpr auto operator+(const char* left, Right&& right){ - return raii::string_cat_expr(right))>(raii::static_string(left), std::forward(right)); -} - -template::value && std::is_rvalue_reference::value,void>::type* = nullptr> -constexpr auto operator+(Left&& left, const char* right){ - return raii::string_cat_expr::type,raii::static_string>(std::move(left), raii::static_string(right)); -} -template::value && !std::is_rvalue_reference::value,void>::type* = nullptr> -constexpr auto operator+(Left&& left, const char* right){ - return raii::string_cat_expr(left)),raii::static_string>(std::forward(left), raii::static_string(right)); -} - -template::value && - raii::detail::is_string::value && - std::is_rvalue_reference::value && - std::is_rvalue_reference::value, - void>::type* = nullptr> -constexpr auto operator+(Left&& l, Right&& r){ - return raii::string_cat_expr::type,typename std::remove_reference::type>(std::move(l), std::move(r)); -} -template::value && - raii::detail::is_string::value && - !std::is_rvalue_reference::value && - !std::is_rvalue_reference::value, - void>::type* = nullptr> -constexpr auto operator+(Left&& l, Right&& r){ - return raii::string_cat_expr(l)),decltype(std::forward(r))>(std::forward(l), std::forward(r)); -} -template::value && - raii::detail::is_string::value && - std::is_rvalue_reference::value && - !std::is_rvalue_reference::value, - void>::type* = nullptr> -constexpr auto operator+(Left&& l, Right&& r){ - return raii::string_cat_expr::type,decltype(std::forward(r))>(std::move(l), std::forward(r)); -} -template::value && - raii::detail::is_string::value && - !std::is_rvalue_reference::value && - std::is_rvalue_reference::value, - void>::type* = nullptr> -constexpr auto operator+(Left&& l, Right&& r){ - return raii::string_cat_expr(l)),typename std::remove_reference::type>(std::forward(l), std::move(r)); -} - -template::value&&raii::detail::is_string::value,void>::type* = nullptr> -decltype(auto) operator+=(Left& l, Right&& r){ - return l = (l + std::forward(r)); -} -template::value,void>::type* = nullptr> -decltype(auto) operator+=(Left& l, const char* r){ - return l = (l + r); -} - -#ifdef RAII_BINARY_HPP -#include "raii/binary_string_conv.hpp" -#endif - -#endif diff --git a/include/raii/string_base.tpp b/include/raii/string_base.tpp deleted file mode 100644 index 682a471..0000000 --- a/include/raii/string_base.tpp +++ /dev/null @@ -1,247 +0,0 @@ -/** - This file is a part of rexy's matrix client - Copyright (C) 2019 rexy712 - - This program 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. - - This program 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 this program. If not, see . -*/ - -#ifndef RAII_STRING_BASE_TPP -#define RAII_STRING_BASE_TPP - -#include //forward, move, swap, etc -#include //memcpy -#include //strlen, strcpy -#include //max - -namespace raii{ - template - string_intermediary::string_intermediary(char* data, size_t len): - string_base(data, len){} - template - string_intermediary::string_intermediary(char* data, size_t len, size_t cap): - string_base(data, len, cap){} - template - string_intermediary::string_intermediary(const char* data, size_t len): - string_base(reinterpret_cast(len ? Allocator::copy(data, len+1) : nullptr), len) - { - m_data[len] = 0; - } - template - string_intermediary::string_intermediary(const char* data): - string_base(data ? strlen(data) : 0) - { - if(m_cap){ - m_data = reinterpret_cast(Allocator::copy(data, m_cap+1)); - m_length = m_cap; - } - } - template - string_intermediary::string_intermediary(size_t len): - string_base(reinterpret_cast(len ? Allocator::allocate(len+1) : nullptr), len) - { - m_data[len] = 0; - } - template - string_intermediary::string_intermediary(size_t len, size_t cap): - string_base(reinterpret_cast(len ? Allocator::allocate(len+1) : nullptr), len, cap) - { - m_data[len] = 0; - } - - //normal copy and move ctors - template - string_intermediary::string_intermediary(const string_intermediary& b): - string_base(reinterpret_cast(b.m_length ? Allocator::copy(b.m_data, b.m_length+1) : nullptr), b.m_length, b.m_cap){} - template - string_intermediary::string_intermediary(string_intermediary&& s): - string_base(std::exchange(s.m_data, nullptr), s.m_length, s.m_cap){} - - template - string_intermediary::string_intermediary(const string_base& b): - string_base(reinterpret_cast(b.length() ? Allocator::copy(b.get(), b.length()+1) : nullptr), b.length(), b.capacity()){} - - //dtor - template - string_intermediary::~string_intermediary(void){ - Allocator::free(m_data); - } - - template - string_intermediary& string_intermediary::operator=(const string_intermediary& s){ - if(s.m_length < m_length){ - memcpy(m_data, s.m_data, s.m_length+1); - m_length = s.m_length; - return *this; - } - string_intermediary tmp(s); - return (*this = std::move(tmp)); - } - template - string_intermediary& string_intermediary::operator=(string_intermediary&& s){ - std::swap(m_data, s.m_data); - m_length = s.m_length; - m_cap = s.m_cap; - return *this; - } - //Copy from c string - template - string_intermediary& string_intermediary::operator=(const char* c){ - return _copy_string(c, strlen(c)); - } - //Copy from other string_base - template - string_intermediary& string_intermediary::operator=(const string_base& s){ - return _copy_string(s.get(), s.length()); - } - - //Replace managed pointer. Frees existing value - template - void string_intermediary::reset(char* val){ - Allocator::free(m_data); - m_data = val; - m_length = val ? strlen(val) : 0; - m_cap = m_length; - } - template - void string_intermediary::reset(char* val, size_t len){ - Allocator::free(m_data); - m_data = val; - m_length = len; - m_cap = len; - } - template - bool string_intermediary::resize(size_t newsize){ - if(newsize < m_cap) - return false; - string_intermediary tmp(newsize); - memcpy(tmp.get(), m_data, m_length); - tmp[m_length] = 0; - *this = std::move(tmp); - return true; - } - template - void string_intermediary::append(const char* data, size_t len){ - if(len+m_length <= m_cap){ - memcpy(m_data+m_length, data, len); - m_length += len; - m_data[m_length] = 0; - }else{ - string_intermediary tmp(std::max(m_length + len, m_cap*2)); - memcpy(tmp.m_data, m_data, m_length); - memcpy(tmp.m_data+m_length, data, len); - tmp.m_length = len+m_length; - tmp[m_length+len] = 0; - *this = std::move(tmp); - } - } - template - void string_intermediary::append(const char* data){ - if(data) - append(data, strlen(data)); - } - template - void string_intermediary::append(const string_base& s){ - append(s.get(), s.length()); - } - - template - string_intermediary& string_intermediary::_copy_string(const char* s, size_t len){ - if(!len){ - Allocator::free(m_data); - m_length = 0; - m_cap = 0; - return *this; - } - if(len <= m_length){ - strcpy(m_data, s); - }else{ - Allocator::free(m_data); - m_cap = std::max(len, m_cap*2); - m_data = reinterpret_cast(Allocator::copy(s, m_cap+1)); - if(!m_data){ - m_length = 0; - m_cap = 0; - return *this; - } - } - m_length = len; - return *this; - } - - - template - template - constexpr string_cat_expr::string_cat_expr(T&& l, U&& r): - m_l(std::forward(l)), - m_r(std::forward(r)){} - template - constexpr string_cat_expr::string_cat_expr(const string_cat_expr& s): - m_l(std::forward(s.m_l)), - m_r(std::forward(s.m_r)){} - template - constexpr string_cat_expr::string_cat_expr(string_cat_expr&& s): - m_l(std::forward(s.m_l)), - m_r(std::forward(s.m_r)){} - - template - constexpr size_t string_cat_expr::length(void)const{ - return m_l.length() + m_r.length(); - } - template - template - string_cat_expr::operator string_intermediary(void){ - size_t len = length(); - string_intermediary ret(len); - detail::appender> append(ret); - append(*this); - return ret; - } - template - constexpr const Left& string_cat_expr::left(void)const{ - return m_l; - } - template - constexpr const Right& string_cat_expr::right(void)const{ - return m_r; - } - - - template - constexpr static_string::static_string(const char(&str)[N]): - string_base(const_cast(str), N, N){} - constexpr static_string::static_string(const char* str, size_t len): - string_base(const_cast(str), len, len){} - constexpr static_string::static_string(const static_string& s): - string_base(s.m_data, s.m_length, s.m_length){} - constexpr static_string::static_string(static_string&& s): - string_base(s.m_data, s.m_length, s.m_length){} - - namespace detail{ - template - appender::appender(Targ& t): m_targ(t){} - template - template - void appender::operator()(const string_cat_expr& str){ - (*this)(str.left()); - (*this)(str.right()); - } - template - void appender::operator()(const string_base& str){ - m_targ.append(str.get(), str.length()); - } - } - -} //namespace raii - -#endif diff --git a/include/raii/util.hpp b/include/raii/util.hpp index 727c388..6f91145 100644 --- a/include/raii/util.hpp +++ b/include/raii/util.hpp @@ -19,7 +19,7 @@ #ifndef RAII_UTIL_HPP #define RAII_UTIL_HPP -#include "raii/string.hpp" +#include namespace raii{ @@ -44,20 +44,20 @@ namespace raii{ return len; } } - template::value && !detail::is_concrete_string::value,void>::type* = nullptr> - string json_escape(T&& t){ + template::value && !rexy::detail::is_concrete_string::value,void>::type* = nullptr> + rexy::string json_escape(T&& t){ auto tup = t.get(); size_t len = detail::_calc_escaped_len_all(tup); - char* tmp = reinterpret_cast(string::allocator_type::allocate(len+1)); + char* tmp = reinterpret_cast(rexy::string::allocator_type::allocate(len+1)); detail::_js_assign(tmp, tup, 0); tmp[len] = 0; - return string(tmp, len); + return rexy::string(tmp, len); } - string json_escape(const string_base& str); + rexy::string json_escape(const rexy::string_base& str); size_t intlen(int i); - raii::string itostr(int i); + rexy::string itostr(int i); } #endif diff --git a/makefile b/makefile index cc45f59..b872960 100644 --- a/makefile +++ b/makefile @@ -32,7 +32,7 @@ RELEASE?=0 ifneq ($(WINDOWS),1) CXX::=g++ - LDLIBS::=-lcurl -lrjp + LDLIBS::=-lcurl -lrjp -lrexy LDFLAGS::= STRIP::=strip RANLIB::=ranlib diff --git a/src/matrix/client.cpp b/src/matrix/client.cpp index ebdc424..2c0ce59 100644 --- a/src/matrix/client.cpp +++ b/src/matrix/client.cpp @@ -19,8 +19,8 @@ #include "matrix/client.hpp" #include "matrix/fat_strings.hpp" #include "matrix/json_targets.hpp" -#include "raii/filerd.hpp" -#include "raii/string_base.hpp" +#include +#include #include "raii/rjp_ptr.hpp" #include "raii/util.hpp" @@ -32,19 +32,19 @@ namespace matrix{ m_urls(std::make_shared(*ses)){} //networked setter - netreturn client::set_display_name(const raii::string_base& newname){ + netreturn client::set_display_name(const rexy::string_base& newname){ _put_curl(json::_displayname_set(newname), m_urls->displayname(*m_ses, m_ses->userid), raii::curl_llist()); - return netreturn(raii::string(), raii::string(), http_status()); + return netreturn(rexy::string(), rexy::string(), http_status()); } - netreturn client::set_profile_picture(const raii::string_base& media_url){ + netreturn client::set_profile_picture(const rexy::string_base& media_url){ _put_curl(json::_avatar_set(media_url), m_urls->profile_picture(), raii::curl_llist()); - return netreturn(raii::string(), raii::string(), http_status()); + return netreturn(rexy::string(), rexy::string(), http_status()); } - netreturn client::set_presence(const raii::string_base& status){ + netreturn client::set_presence(const rexy::string_base& status){ _put_curl(json::_presence_set(status), m_urls->presence(*m_ses, m_ses->userid), raii::curl_llist()); - return netreturn(raii::string(), raii::string(), http_status()); + return netreturn(rexy::string(), rexy::string(), http_status()); } - netreturn client::get_presence(const raii::string_base& userid){ + netreturn client::get_presence(const rexy::string_base& userid){ return _get_and_find(m_urls->presence(*m_ses, userid), json::keys::presence()); } @@ -52,18 +52,18 @@ namespace matrix{ netreturn client::get_display_name(void)const{ return _get_and_find(m_urls->displayname(*m_ses, m_ses->userid), json::keys::displayname()); } - netreturn client::get_display_name(const raii::string_base& userid)const{ + netreturn client::get_display_name(const rexy::string_base& userid)const{ return _get_and_find(m_urls->displayname(*m_ses, userid), json::keys::displayname()); } netreturn client::get_profile_picture(void)const{ return _get_and_find(m_urls->profile_picture(), json::keys::avatarurl()); } - netreturn client::room_alias_to_id(const raii::string_base& alias)const{ + netreturn client::room_alias_to_id(const rexy::string_base& alias)const{ auto tmp = m_curl.encode(alias, alias.length()); - return _get_and_find(raii::string(m_urls->alias_lookup() + tmp), json::keys::event::roomid()); + return _get_and_find(rexy::string(m_urls->alias_lookup() + tmp), json::keys::event::roomid()); } netreturn> client::list_rooms(void)const{ - raii::string reply = _get_curl(m_urls->room_list()); + rexy::string reply = _get_curl(m_urls->room_list()); if(!reply) return _create_netreturn(reply, http_status()); @@ -86,13 +86,13 @@ namespace matrix{ } //room membership - netreturn client::create_room(const raii::string_base& name, const raii::string_base& alias)const{ + netreturn client::create_room(const rexy::string_base& name, const rexy::string_base& alias)const{ return _post_and_find(json::_create_room(name, alias), m_urls->create_room(), raii::curl_llist(), json::keys::event::roomid()); } - roomcxn client::spawn_room(const raii::string_base& roomid)const{ + roomcxn client::spawn_room(const rexy::string_base& roomid)const{ return roomcxn(m_ses, roomid); } - roomcxn client::spawn_room(raii::string&& roomid)const{ + roomcxn client::spawn_room(rexy::string&& roomid)const{ return roomcxn(m_ses, std::move(roomid)); } @@ -101,7 +101,7 @@ namespace matrix{ return _upload_file(file, raii::curl_llist{}); } netreturn client::upload_image(const image_details& file)const{ - raii::curl_llist headers(raii::string("Content-Type: "_ss + file.mimetype)); + raii::curl_llist headers(rexy::string("Content-Type: "_ss + file.mimetype)); netreturn upfile = _upload_file(file, headers); netreturn retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus()); retval.value().m_width = file.width; @@ -110,14 +110,14 @@ namespace matrix{ return retval; } netreturn client::upload_audio(const audio_details& file)const{ - raii::curl_llist headers(raii::string("Content-Type: "_ss + file.mimetype)); + raii::curl_llist headers(rexy::string("Content-Type: "_ss + file.mimetype)); netreturn upfile = _upload_file(file, headers); netreturn retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus()); retval.value().m_mimetype = file.mimetype; return retval; } netreturn client::upload_video(const video_details& file)const{ - raii::curl_llist headers(raii::string("Content-Type: "_ss + file.mimetype)); + raii::curl_llist headers(rexy::string("Content-Type: "_ss + file.mimetype)); netreturn upfile = _upload_file(file, headers); netreturn retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus()); retval.value().m_width = file.width; @@ -127,7 +127,7 @@ namespace matrix{ } static size_t _thumbnail_header_callback(char* ptr, size_t size, size_t nmemb, void* userdata){ - raii::string* data = reinterpret_cast(userdata); + rexy::string* data = reinterpret_cast(userdata); if(size*nmemb > 13 && !strncmp("Content-Type:", ptr, 13)){ (*data) += (ptr + 13); data->get()[data->length()-1] = 0; @@ -137,7 +137,7 @@ namespace matrix{ netreturn client::create_thumbnail(uploaded_image& info)const{ image_details i; - raii::string reply_header; + rexy::string reply_header; if(info.thumb_width() > info.width() || info.thumb_height() > info.height()){ info.m_thumb.m_url = info.m_fileurl; info.m_thumb.m_size = info.m_filesize; @@ -149,7 +149,7 @@ namespace matrix{ m_curl.setopt(CURLOPT_HEADERFUNCTION, NULL); m_curl.setopt(CURLOPT_HEADERDATA, NULL); if(!i.data) - return netreturn(raii::string(), raii::string(), http_status()); + return netreturn(rexy::string(), rexy::string(), http_status()); i.width = info.thumb_width(); i.height = info.thumb_height(); i.mimetype = std::move(reply_header); @@ -165,21 +165,21 @@ namespace matrix{ netreturn client::create_thumbnail(uploaded_video& info)const{ return create_thumbnail(static_cast(info)); } - raii::binary client::download_file(const raii::string_base& url){ + rexy::binary client::download_file(const rexy::string_base& url){ return _get_curl_binary(m_urls->file_download(*m_ses, url)); } netreturn client::sync(size_t timeout){ return sync(timeout, {}); } netreturn client::sync(size_t timeout, const sync::client_response& last){ - raii::string reply; + rexy::string reply; if(last.raw_handle()) reply = _get_curl(m_urls->sync(*m_ses, last.next_batch(), raii::itostr(timeout))); else reply = _get_curl(m_urls->sync(*m_ses, ""_ss, raii::itostr(timeout))); if(!reply) - return netreturn(raii::string(), raii::string(), http_status(), {nullptr}); + return netreturn(rexy::string(), rexy::string(), http_status(), {nullptr}); raii::rjp_ptr root(rjp_parse(reply)); netreturn retval = _create_netreturn(root, http_status()); if(!root) @@ -210,7 +210,7 @@ namespace matrix{ } netreturn client::_upload_file(const file_details& file, const raii::curl_llist& header)const{ - raii::string fileurl; + rexy::string fileurl; internal_upload_data upload_data = {file.data.get(), file.data.size()}; m_curl.postreq(); m_curl.setopt(CURLOPT_POSTFIELDS, NULL); diff --git a/src/matrix/connection.cpp b/src/matrix/connection.cpp index d76a8b3..56dea8c 100644 --- a/src/matrix/connection.cpp +++ b/src/matrix/connection.cpp @@ -18,7 +18,7 @@ #include "matrix/connection.hpp" #include "raii/rjp_ptr.hpp" -#include "raii/string_base.hpp" +#include #include //size_t #include //min, max @@ -37,7 +37,7 @@ namespace matrix{ const raii::rjp_string& connection::userid(void)const{ return m_ses->userid; } - const raii::string& connection::useragent(void)const{ + const rexy::string& connection::useragent(void)const{ return m_ses->useragent; } @@ -46,21 +46,21 @@ namespace matrix{ } size_t connection::_reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata){ - raii::string* data = reinterpret_cast(userdata); + rexy::string* data = reinterpret_cast(userdata); data->append(ptr, size*nmemb); return size*nmemb; } size_t connection::_binary_reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata){ - raii::binary* data = reinterpret_cast(userdata); + rexy::binary* data = reinterpret_cast(userdata); data->append(ptr, size*nmemb); return size*nmemb; } - void connection::_get_curl_setup(const raii::string_base& url)const{ + void connection::_get_curl_setup(const rexy::string_base& url)const{ m_curl.getreq(); m_curl.seturl(url); m_curl.setheader(raii::curl_llist{}); } - void connection::_post_curl_setup(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header)const{ + void connection::_post_curl_setup(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header)const{ m_curl.postreq(); m_curl.setpostdata(postdata.get(), postdata.length()); m_curl.seturl(url); @@ -75,7 +75,7 @@ namespace matrix{ src->data += to_copy; return to_copy; } - void connection::_put_curl_setup(put_data& data, const raii::string_base& url, const raii::curl_llist& header)const{ + void connection::_put_curl_setup(put_data& data, const rexy::string_base& url, const raii::curl_llist& header)const{ m_curl.putreq(); m_curl.setopt(CURLOPT_POSTFIELDS, data.data); m_curl.setopt(CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t)data.len); @@ -86,15 +86,15 @@ namespace matrix{ m_curl.setopt(CURLOPT_INFILESIZE, (curl_off_t)data.len); } - void connection::_set_curl_useragent(const raii::string_base& useragent){ + void connection::_set_curl_useragent(const rexy::string_base& useragent){ m_curl.setuseragent(useragent); } bool connection::_perform_curl(void)const{ CURLcode res = m_curl.perform(); return (res == CURLE_OK); } - raii::string connection::_get_curl(const raii::string_base& url, reply_callback_fun fun)const{ - raii::string reply; + rexy::string connection::_get_curl(const rexy::string_base& url, reply_callback_fun fun)const{ + rexy::string reply; _get_curl_setup(url); m_curl.setwritefun(fun); m_curl.setwritedata(&reply); @@ -102,8 +102,8 @@ namespace matrix{ return {}; return reply; } - raii::binary connection::_get_curl_binary(const raii::string_base& url, binary_callback_fun fun)const{ - raii::binary reply; + rexy::binary connection::_get_curl_binary(const rexy::string_base& url, binary_callback_fun fun)const{ + rexy::binary reply; _get_curl_setup(url); m_curl.setwritefun(fun); m_curl.setwritedata(&reply); @@ -111,8 +111,8 @@ namespace matrix{ return {}; return reply; } - raii::string connection::_post_curl(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, reply_callback_fun fun)const{ - raii::string reply; + rexy::string connection::_post_curl(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, reply_callback_fun fun)const{ + rexy::string reply; _post_curl_setup(postdata, url, header); m_curl.setwritefun(fun); m_curl.setwritedata(&reply); @@ -120,8 +120,8 @@ namespace matrix{ return {}; return reply; } - raii::binary connection::_post_curl_binary(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, binary_callback_fun fun)const{ - raii::binary reply; + rexy::binary connection::_post_curl_binary(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, binary_callback_fun fun)const{ + rexy::binary reply; _post_curl_setup(postdata, url, header); m_curl.setwritefun(fun); m_curl.setwritedata(&reply); @@ -129,8 +129,8 @@ namespace matrix{ return {}; return reply; } - raii::string connection::_put_curl(const raii::string_base& putdata, const raii::string_base& url, const raii::curl_llist& header, reply_callback_fun fun)const{ - raii::string reply; + rexy::string connection::_put_curl(const rexy::string_base& putdata, const rexy::string_base& url, const raii::curl_llist& header, reply_callback_fun fun)const{ + rexy::string reply; put_data data{putdata.get(), putdata.length()}; m_curl.setwritefun(fun); m_curl.setwritedata(&reply); @@ -142,8 +142,8 @@ namespace matrix{ return {}; return reply; } - raii::binary connection::_put_curl_binary(const raii::string_base& putdata, const raii::string_base& url, const raii::curl_llist& header, binary_callback_fun fun)const{ - raii::binary reply; + rexy::binary connection::_put_curl_binary(const rexy::string_base& putdata, const rexy::string_base& url, const raii::curl_llist& header, binary_callback_fun fun)const{ + rexy::binary reply; put_data data{putdata.get(), putdata.length()}; m_curl.setwritefun(fun); m_curl.setwritedata(&reply); @@ -155,10 +155,10 @@ namespace matrix{ return {}; return reply; } - netreturn connection::_post_and_find(const raii::string_base& data, const raii::string_base& url, - const raii::curl_llist& header, const raii::string_base& target)const + netreturn connection::_post_and_find(const rexy::string_base& data, const rexy::string_base& url, + const raii::curl_llist& header, const rexy::string_base& target)const { - raii::string reply = _post_curl(data, url, header); + rexy::string reply = _post_curl(data, url, header); if(!reply) return _create_netreturn(reply, http_status()); raii::rjp_ptr root(rjp_parse(reply)); @@ -166,10 +166,10 @@ namespace matrix{ retval.value() = _curl_reply_search(reply, target); return retval; } - netreturn connection::_put_and_find(const raii::string_base& data, const raii::string_base& url, - const raii::curl_llist& header, const raii::string_base& target)const + netreturn connection::_put_and_find(const rexy::string_base& data, const rexy::string_base& url, + const raii::curl_llist& header, const rexy::string_base& target)const { - raii::string reply = _put_curl(data, url, header); + rexy::string reply = _put_curl(data, url, header); if(!reply) return _create_netreturn(reply, http_status()); raii::rjp_ptr root(rjp_parse(reply)); @@ -177,8 +177,8 @@ namespace matrix{ retval.value() = _curl_reply_search(reply, target); return retval; } - netreturn connection::_get_and_find(const raii::string_base& url, const raii::string_base& target)const{ - raii::string reply = _get_curl(url); + netreturn connection::_get_and_find(const rexy::string_base& url, const rexy::string_base& target)const{ + rexy::string reply = _get_curl(url); if(!reply) return _create_netreturn(reply, http_status()); raii::rjp_ptr root(rjp_parse(reply)); @@ -186,11 +186,11 @@ namespace matrix{ retval.value() = _curl_reply_search(reply, target); return retval; } - raii::rjp_string connection::_curl_reply_search(const raii::string_base& reply, const raii::string_base& target)const{ + raii::rjp_string connection::_curl_reply_search(const rexy::string_base& reply, const rexy::string_base& target)const{ raii::rjp_ptr root(rjp_parse(reply)); return _curl_reply_search(root, target); } - raii::rjp_string connection::_curl_reply_search(const raii::rjp_ptr& root, const raii::string_base& target)const{ + raii::rjp_string connection::_curl_reply_search(const raii::rjp_ptr& root, const rexy::string_base& target)const{ if(!root) return {}; RJP_value* res = rjp_search_member(root.get(), target.get()); @@ -201,7 +201,7 @@ namespace matrix{ return raii::rjp_string(res); } - void connection::_set_curl_defaults(const raii::string_base& useragent)const{ + void connection::_set_curl_defaults(const rexy::string_base& useragent)const{ #ifdef _WIN32 //temporary measure to make ssl connections work on wine m_curl.setopt(CURLOPT_CAINFO, "./cacert.pem"); @@ -215,7 +215,7 @@ namespace matrix{ m_curl.setopt(CURLOPT_TCP_KEEPALIVE, 1L); //m_curl.setopt(CURLOPT_FAILONERROR, 0L); } - netreturn_base connection::_create_netreturn(const raii::string_base& mxjson, int httpstatus){ + netreturn_base connection::_create_netreturn(const rexy::string_base& mxjson, int httpstatus){ if(!mxjson) return netreturn_base(""_ss, ""_ss, httpstatus); raii::rjp_ptr root(rjp_parse(mxjson.get())); diff --git a/src/matrix/events.cpp b/src/matrix/events.cpp index 45b7b40..06ac19e 100644 --- a/src/matrix/events.cpp +++ b/src/matrix/events.cpp @@ -30,8 +30,8 @@ namespace matrix::sync{ m_event(std::exchange(ev.m_event, nullptr)), m_type(std::exchange(ev.m_type, nullptr)), m_content(std::exchange(ev.m_content, nullptr)){} - raii::static_string event::type(void)const&{ - return raii::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length); + rexy::static_string event::type(void)const&{ + return rexy::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length); } raii::rjp_string event::type(void)&&{ return raii::rjp_string(std::exchange(m_type, nullptr)); @@ -50,7 +50,7 @@ namespace matrix::sync{ } //Room event - room_event::room_event(RJP_value* ev, const raii::string_base& roomid): + room_event::room_event(RJP_value* ev, const rexy::string_base& roomid): room_event_base(roomid), event(ev) { if(!ev) @@ -68,15 +68,15 @@ namespace matrix::sync{ m_unsigned(std::exchange(ev.m_unsigned, nullptr)), m_redacts(std::exchange(ev.m_redacts, nullptr)), m_origin_server_ts(ev.m_origin_server_ts){} - raii::static_string room_event::eventid(void)const&{ - return raii::static_string(rjp_get_cstring(m_id)->value, rjp_get_cstring(m_id)->length); + rexy::static_string room_event::eventid(void)const&{ + return rexy::static_string(rjp_get_cstring(m_id)->value, rjp_get_cstring(m_id)->length); } raii::rjp_string room_event::eventid(void)&&{ return raii::rjp_string(std::exchange(m_id, nullptr)); } - raii::static_string room_event::sender(void)const&{ - return raii::static_string(rjp_get_cstring(m_sender)->value, rjp_get_cstring(m_sender)->length); + rexy::static_string room_event::sender(void)const&{ + return rexy::static_string(rjp_get_cstring(m_sender)->value, rjp_get_cstring(m_sender)->length); } raii::rjp_string room_event::sender(void)&&{ return raii::rjp_string(std::exchange(m_sender, nullptr)); @@ -90,10 +90,10 @@ namespace matrix::sync{ RJP_value* room_event::extra(void){ return m_unsigned; } - raii::static_string room_event::redacts(void)const&{ + rexy::static_string room_event::redacts(void)const&{ if(!m_redacts) - return raii::static_string(); - return raii::static_string(rjp_get_cstring(m_redacts)->value, rjp_get_cstring(m_redacts)->length); + return rexy::static_string(); + return rexy::static_string(rjp_get_cstring(m_redacts)->value, rjp_get_cstring(m_redacts)->length); } raii::rjp_string room_event::redacts(void)&&{ if(!m_redacts) @@ -102,7 +102,7 @@ namespace matrix::sync{ } //Room state event - room_state_event::room_state_event(RJP_value* ev, const raii::string_base& roomid): + room_state_event::room_state_event(RJP_value* ev, const rexy::string_base& roomid): room_event(ev, roomid) { if(!ev) @@ -113,24 +113,24 @@ namespace matrix::sync{ m_prev_content = rjp_search_member(m_unsigned, json::keys::event::prev_content()); } } - raii::static_string room_state_event::state_key(void)const&{ - return raii::static_string(rjp_get_cstring(m_state_key)->value, rjp_get_cstring(m_state_key)->length); + rexy::static_string room_state_event::state_key(void)const&{ + return rexy::static_string(rjp_get_cstring(m_state_key)->value, rjp_get_cstring(m_state_key)->length); } raii::rjp_string room_state_event::state_key(void)&&{ return raii::rjp_string(std::exchange(m_state_key, nullptr)); } - raii::static_string room_state_event::prev_content(void)const&{ - return raii::static_string(rjp_get_cstring(m_prev_content)->value, rjp_get_cstring(m_prev_content)->length); + rexy::static_string room_state_event::prev_content(void)const&{ + return rexy::static_string(rjp_get_cstring(m_prev_content)->value, rjp_get_cstring(m_prev_content)->length); } raii::rjp_string room_state_event::prev_content(void)&&{ return raii::rjp_string(std::exchange(m_prev_content, nullptr)); } - room_ephemeral_event::room_ephemeral_event(RJP_value* ev, const raii::string_base& roomid): + room_ephemeral_event::room_ephemeral_event(RJP_value* ev, const rexy::string_base& roomid): room_event_base(roomid), event(ev){} //Room message event - room_message_event::room_message_event(RJP_value* ev, const raii::string_base& roomid): + room_message_event::room_message_event(RJP_value* ev, const rexy::string_base& roomid): room_event(ev, roomid), m_body(rjp_search_member(m_content, json::keys::event::contentbody::body())), m_type(rjp_search_member(m_content, json::keys::event::contentbody::msgtype())){} @@ -138,14 +138,14 @@ namespace matrix::sync{ room_event(std::move(ev)), m_body(rjp_search_member(m_content, json::keys::event::contentbody::body())), m_type(rjp_search_member(m_content, json::keys::event::contentbody::msgtype())){} - raii::static_string room_message_event::body(void)const&{ - return raii::static_string(rjp_get_cstring(m_body)->value, rjp_get_cstring(m_body)->length); + rexy::static_string room_message_event::body(void)const&{ + return rexy::static_string(rjp_get_cstring(m_body)->value, rjp_get_cstring(m_body)->length); } raii::rjp_string room_message_event::body(void)&&{ return raii::rjp_string(m_body); } - raii::static_string room_message_event::msgtype(void)const&{ - return raii::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length); + rexy::static_string room_message_event::msgtype(void)const&{ + return rexy::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length); } raii::rjp_string room_message_event::msgtype(void)&&{ return raii::rjp_string(m_type); diff --git a/src/matrix/fat_strings.cpp b/src/matrix/fat_strings.cpp index 0013125..3403063 100644 --- a/src/matrix/fat_strings.cpp +++ b/src/matrix/fat_strings.cpp @@ -18,24 +18,24 @@ #include "matrix/fat_strings.hpp" #include "matrix/upload_info.hpp" -#include "raii/string_base.hpp" +#include #include "matrix/json_targets.hpp" #include "raii/util.hpp" namespace matrix::json{ - static constexpr auto quote(const raii::string_base& str){ + static constexpr auto quote(const rexy::string_base& str){ return "\"" + str + "\""; } - static constexpr auto key(const raii::string_base& str){ + static constexpr auto key(const rexy::string_base& str){ return "\"" + str + "\":"; } - static constexpr raii::static_string open_brace(void){ + static constexpr rexy::static_string open_brace(void){ return "{"_ss; } - static constexpr raii::static_string close_brace(void){ + static constexpr rexy::static_string close_brace(void){ return "}"_ss; } - static constexpr raii::static_string comma(void){ + static constexpr rexy::static_string comma(void){ return ","_ss; } template @@ -55,18 +55,18 @@ namespace matrix::json{ return key(k) + value; } - raii::static_string _empty(void){ + rexy::static_string _empty(void){ return "{}"_ss; } - raii::string _image_body(const uploaded_image& image){ - raii::string url = raii::json_escape(image.url()); - const raii::string_base* thumburl; + rexy::string _image_body(const uploaded_image& image){ + rexy::string url = raii::json_escape(image.url()); + const rexy::string_base* thumburl; if(image.thumb_url()) thumburl = &image.thumb_url(); else thumburl = &url; - return raii::string( + return rexy::string( object( member(json::keys::event::contentbody::body(), quote(raii::json_escape(image.name()))), member(json::keys::event::contentbody::info(), object( @@ -87,8 +87,8 @@ namespace matrix::json{ )); } - raii::string _video_body(const uploaded_video& video){ - return raii::string( + rexy::string _video_body(const uploaded_video& video){ + return rexy::string( object( member(json::keys::event::contentbody::body(), quote(raii::json_escape(video.name()))), member(json::keys::event::contentbody::info(), object( @@ -108,8 +108,8 @@ namespace matrix::json{ member(json::keys::event::contentbody::url(), quote(raii::json_escape(video.url()))) )); } - raii::string _file_body(const uploaded_file& file){ - return raii::string( + rexy::string _file_body(const uploaded_file& file){ + return rexy::string( object( member(json::keys::event::contentbody::body(), quote(raii::json_escape(file.name()))), member(json::keys::event::contentbody::info(), object( @@ -120,8 +120,8 @@ namespace matrix::json{ )); } - raii::string _audio_body(const uploaded_audio& audio){ - return raii::string( + rexy::string _audio_body(const uploaded_audio& audio){ + return rexy::string( object( member(json::keys::event::contentbody::body(), quote(raii::json_escape(audio.name()))), member(json::keys::event::contentbody::info(), object( @@ -133,22 +133,22 @@ namespace matrix::json{ )); } - raii::string _message_body(const raii::string_base& msg){ - return raii::string( + rexy::string _message_body(const rexy::string_base& msg){ + return rexy::string( object( member(json::keys::event::contentbody::body(), quote(raii::json_escape(msg))), member(json::keys::event::contentbody::msgtype(), quote("m.text"_ss)) )); } - raii::string _notice_body(const raii::string_base& msg){ - return raii::string( + rexy::string _notice_body(const rexy::string_base& msg){ + return rexy::string( object( member(json::keys::event::contentbody::body(), quote(raii::json_escape(msg))), member(json::keys::event::contentbody::msgtype(), quote("m.notice"_ss)) )); } - raii::string _login_password(const raii::string_base& username, const raii::string_base& password){ - return raii::string( + rexy::string _login_password(const rexy::string_base& username, const rexy::string_base& password){ + return rexy::string( object( member(json::keys::auth::type(), quote("m.login.password"_ss)), member(json::keys::auth::identifier(), object( @@ -158,8 +158,8 @@ namespace matrix::json{ member(json::keys::auth::password(), quote(raii::json_escape(password))) )); } - raii::string _change_psk_password(const raii::string_base& userid, const raii::string_base& newpass, const raii::string_base& oldpass, const raii::string_base& session){ - return raii::string( + rexy::string _change_psk_password(const rexy::string_base& userid, const rexy::string_base& newpass, const rexy::string_base& oldpass, const rexy::string_base& session){ + return rexy::string( object( member(json::keys::auth::newpassword(), quote(raii::json_escape(newpass))), member(json::keys::auth::auth(), object( @@ -170,66 +170,66 @@ namespace matrix::json{ )) )); } - raii::string _displayname_set(const raii::string_base& newname){ - return raii::string( + rexy::string _displayname_set(const rexy::string_base& newname){ + return rexy::string( object( member(json::keys::displayname(), quote(raii::json_escape(newname))) )); } - raii::string _avatar_set(const raii::string_base& mediaurl){ - return raii::string( + rexy::string _avatar_set(const rexy::string_base& mediaurl){ + return rexy::string( object( member(json::keys::avatarurl(), quote(raii::json_escape(mediaurl))) )); } - raii::string _presence_set(const raii::string_base& status){ - return raii::string( + rexy::string _presence_set(const rexy::string_base& status){ + return rexy::string( object( member(json::keys::presence(), quote(status)) )); } - raii::string _create_room(const raii::string_base& name, const raii::string_base& alias){ + rexy::string _create_room(const rexy::string_base& name, const rexy::string_base& alias){ if(alias){ - return raii::string( + return rexy::string( object( member(json::keys::name(), quote(raii::json_escape(name))), member(json::keys::roomaliasname(), quote(raii::json_escape(alias))) )); }else{ - return raii::string( + return rexy::string( object( member(json::keys::name(), quote(raii::json_escape(name))) )); } } - raii::string _userid(const raii::string_base& id){ - return raii::string( + rexy::string _userid(const rexy::string_base& id){ + return rexy::string( object( member(json::keys::auth::userid(), quote(raii::json_escape(id))) )); } - raii::string _userid_reason(const raii::string_base& id, const raii::string_base& reason){ - return raii::string( + rexy::string _userid_reason(const rexy::string_base& id, const rexy::string_base& reason){ + return rexy::string( object( member(json::keys::auth::userid(), quote(raii::json_escape(id))), member(json::reason(), quote(raii::json_escape(reason))) )); } - raii::string _typing(bool active, int timeout){ - return raii::string( + rexy::string _typing(bool active, int timeout){ + return rexy::string( object( member(json::keys::typing(), active ? json::True() : json::False()), member(json::keys::timeout(), raii::itostr(timeout)) )); } - raii::string _redact(const raii::string_base& reason){ - return raii::string( + rexy::string _redact(const rexy::string_base& reason){ + return rexy::string( object( member(json::reason(), quote(raii::json_escape(reason))) )); } - raii::string _room_upgrade(int version){ - return raii::string( + rexy::string _room_upgrade(int version){ + return rexy::string( object( member(json::keys::newversion(), raii::itostr(version)) )); diff --git a/src/matrix/iterable.cpp b/src/matrix/iterable.cpp index 5103eac..3dc6b18 100644 --- a/src/matrix/iterable.cpp +++ b/src/matrix/iterable.cpp @@ -20,22 +20,22 @@ namespace matrix::sync{ template - roomcxn_event_list_base::roomcxn_event_list_base(raii::rjp_ptr& root, RJP_value* event, const raii::string_base& roomid): + roomcxn_event_list_base::roomcxn_event_list_base(raii::rjp_ptr& root, RJP_value* event, const rexy::string_base& roomid): iterable_room_event_base>(event, roomid), m_root(root.release()){} template - raii::static_string roomcxn_event_list_base::start_token(void)const&{ + rexy::static_string roomcxn_event_list_base::start_token(void)const&{ RJP_value* st = rjp_search_member(m_root.get(), "start"); - return raii::static_string(rjp_get_cstring(st)->value, rjp_get_cstring(st)->length); + return rexy::static_string(rjp_get_cstring(st)->value, rjp_get_cstring(st)->length); } template raii::rjp_string roomcxn_event_list_base::start_token(void)&&{ return raii::rjp_string(rjp_search_member(m_root.get(), "start")); } template - raii::static_string roomcxn_event_list_base::end_token(void)const&{ + rexy::static_string roomcxn_event_list_base::end_token(void)const&{ RJP_value* st = rjp_search_member(m_root.get(), "end"); - return raii::static_string(rjp_get_cstring(st)->value, rjp_get_cstring(st)->length); + return rexy::static_string(rjp_get_cstring(st)->value, rjp_get_cstring(st)->length); } template raii::rjp_string roomcxn_event_list_base::end_token(void)&&{ diff --git a/src/matrix/rest/client_url_list.cpp b/src/matrix/rest/client_url_list.cpp index af7f28f..53eaf1c 100644 --- a/src/matrix/rest/client_url_list.cpp +++ b/src/matrix/rest/client_url_list.cpp @@ -17,7 +17,7 @@ */ #include "matrix/rest/client_url_list.hpp" -#include "raii/string.hpp" +#include #include "raii/util.hpp" namespace matrix::rest{ @@ -25,41 +25,41 @@ namespace matrix::rest{ client_url_list::client_url_list(const session_info& session){ repopulate(session); } - const raii::string& client_url_list::create_room(void)const{ + const rexy::string& client_url_list::create_room(void)const{ return m_create_room; } - const raii::string& client_url_list::file_upload(void)const{ + const rexy::string& client_url_list::file_upload(void)const{ return m_file_upload; } - const raii::string& client_url_list::room_list(void)const{ + const rexy::string& client_url_list::room_list(void)const{ return m_room_list; } - const raii::string& client_url_list::alias_lookup(void)const{ + const rexy::string& client_url_list::alias_lookup(void)const{ return m_alias_lookup; } - const raii::string& client_url_list::profile_picture(void)const{ + const rexy::string& client_url_list::profile_picture(void)const{ return m_profile_picture; } - raii::string client_url_list::displayname(const session_info& session, const raii::string_base& userid)const{ - return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/profile/" + userid + "/displayname?access_token=" + session.access_token); + rexy::string client_url_list::displayname(const session_info& session, const rexy::string_base& userid)const{ + return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/profile/" + userid + "/displayname?access_token=" + session.access_token); } - raii::string client_url_list::file_download(const session_info& session, const raii::string_base& fileurl){ - raii::string media = get_server_media_string(fileurl); + rexy::string client_url_list::file_download(const session_info& session, const rexy::string_base& fileurl){ + rexy::string media = get_server_media_string(fileurl); if(!media) return {}; - return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/download/" + media); + return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/download/" + media); } - raii::string client_url_list::file_thumbnail(const session_info& session, const raii::string_base& fileurl, int width, int height, const raii::string_base& method)const{ - raii::string media = get_server_media_string(fileurl); + rexy::string client_url_list::file_thumbnail(const session_info& session, const rexy::string_base& fileurl, int width, int height, const rexy::string_base& method)const{ + rexy::string media = get_server_media_string(fileurl); if(!media) return {}; - return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/thumbnail/" + media + "?width=" + raii::itostr(width) + "&height=" + raii::itostr(height) + "&method=" + method); + return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/thumbnail/" + media + "?width=" + raii::itostr(width) + "&height=" + raii::itostr(height) + "&method=" + method); } - raii::string client_url_list::presence(const session_info& session, const raii::string_base& userid)const{ - return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/presence/" + userid + "/status?access_token=" + session.access_token); + rexy::string client_url_list::presence(const session_info& session, const rexy::string_base& userid)const{ + return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/presence/" + userid + "/status?access_token=" + session.access_token); } - raii::string client_url_list::sync(const session_info& session, const raii::rjp_string& next_batch, const raii::string& timeout){ + rexy::string client_url_list::sync(const session_info& session, const raii::rjp_string& next_batch, const rexy::string& timeout){ if(!next_batch) - return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/sync?access_token=" + session.access_token + "&timeout=" + timeout); - return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/sync?access_token=" + session.access_token + "&timeout=" + timeout + "&since=" + next_batch); + return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/sync?access_token=" + session.access_token + "&timeout=" + timeout); + return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/sync?access_token=" + session.access_token + "&timeout=" + timeout + "&since=" + next_batch); } void client_url_list::repopulate(const session_info& session){ @@ -77,11 +77,11 @@ namespace matrix::rest{ m_alias_lookup.reset(); } - raii::string client_url_list::get_server_media_string(const raii::string_base& url){ + rexy::string client_url_list::get_server_media_string(const rexy::string_base& url){ if(!url || strncmp(url.get(), "mxc://", 6)) return {}; - return raii::string(url.get()+6, url.length()-6); + return rexy::string(url.get()+6, url.length()-6); } } diff --git a/src/matrix/rest/room_url_list.cpp b/src/matrix/rest/room_url_list.cpp index 50427f0..2d62c4f 100644 --- a/src/matrix/rest/room_url_list.cpp +++ b/src/matrix/rest/room_url_list.cpp @@ -21,68 +21,68 @@ namespace matrix{ - room_url_list::room_url_list(const session_info& session, const raii::string_base& roomid): + room_url_list::room_url_list(const session_info& session, const rexy::string_base& roomid): m_typing(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/typing/" + session.userid + "?access_token=" + session.access_token), m_kick(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/kick?access_token=" + session.access_token), m_ban(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/ban?access_token=" + session.access_token), m_unban(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/unban?access_token=" + session.access_token), m_invite(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/invite?access_token=" + session.access_token), m_members(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/joined_members?access_token=" + session.access_token){} - raii::string room_url_list::join(const session_info& session, const raii::string_base& roomid)const{ - return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/leave?access_token=" + session.access_token); + rexy::string room_url_list::join(const session_info& session, const rexy::string_base& roomid)const{ + return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/leave?access_token=" + session.access_token); } - raii::string room_url_list::leave(const session_info& session, const raii::string_base& roomid)const{ - return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/join?access_token=" + session.access_token); + rexy::string room_url_list::leave(const session_info& session, const rexy::string_base& roomid)const{ + return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/join?access_token=" + session.access_token); } - raii::string room_url_list::forget(const session_info& session, const raii::string_base& roomid)const{ - return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/forget?access_token=" + session.access_token); + rexy::string room_url_list::forget(const session_info& session, const rexy::string_base& roomid)const{ + return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/forget?access_token=" + session.access_token); } - raii::string room_url_list::upgrade(const session_info& session, const raii::string_base& roomid)const{ - return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/upgrade?access_token=" + session.access_token); + rexy::string room_url_list::upgrade(const session_info& session, const rexy::string_base& roomid)const{ + return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/upgrade?access_token=" + session.access_token); } - raii::string room_url_list::read_receipt(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const{ - return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/receipt/m.read/" + eventid + "?access_token=" + session.access_token); + rexy::string room_url_list::read_receipt(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const{ + return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/receipt/m.read/" + eventid + "?access_token=" + session.access_token); } - raii::string room_url_list::send(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventtype)const{ - return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/send/" + eventtype + "?access_token=" + session.access_token); + rexy::string room_url_list::send(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventtype)const{ + return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/send/" + eventtype + "?access_token=" + session.access_token); } - raii::string room_url_list::redact(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const{ - return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/redact/" + eventid + "/0?access_token=" + session.access_token); + rexy::string room_url_list::redact(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const{ + return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/redact/" + eventid + "/0?access_token=" + session.access_token); } - raii::string room_url_list::event(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const{ - return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/event/" + eventid + "?access_token=" + session.access_token); + rexy::string room_url_list::event(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const{ + return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/event/" + eventid + "?access_token=" + session.access_token); } - raii::string room_url_list::power_level(const session_info& session, const raii::string_base& roomid)const{ - return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/state/m.room.power_levels?access_token=" + session.access_token); + rexy::string room_url_list::power_level(const session_info& session, const rexy::string_base& roomid)const{ + return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/state/m.room.power_levels?access_token=" + session.access_token); } - const raii::string& room_url_list::typing(void)const{ + const rexy::string& room_url_list::typing(void)const{ return m_typing; } - const raii::string& room_url_list::kick(void)const{ + const rexy::string& room_url_list::kick(void)const{ return m_kick; } - const raii::string& room_url_list::ban(void)const{ + const rexy::string& room_url_list::ban(void)const{ return m_ban; } - const raii::string& room_url_list::unban(void)const{ + const rexy::string& room_url_list::unban(void)const{ return m_unban; } - const raii::string& room_url_list::invite(void)const{ + const rexy::string& room_url_list::invite(void)const{ return m_invite; } - const raii::string& room_url_list::room_members(void)const{ + const rexy::string& room_url_list::room_members(void)const{ return m_members; } - raii::string room_url_list::messages(const session_info& session, const raii::string_base& roomid, - const raii::string_base& from, const raii::string_base& to, - const raii::string_base& dir, int limit)const + rexy::string room_url_list::messages(const session_info& session, const rexy::string_base& roomid, + const rexy::string_base& from, const rexy::string_base& to, + const rexy::string_base& dir, int limit)const { if(to) - return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&to=" + to + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + session.access_token); + return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&to=" + to + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + session.access_token); else - return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + session.access_token); + return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + session.access_token); } - void room_url_list::repopulate(const session_info& session, const raii::string_base& roomid){ + void room_url_list::repopulate(const session_info& session, const rexy::string_base& roomid){ m_typing = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/typing/" + session.userid + "?access_token=" + session.access_token; m_kick = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/kick?access_token=" + session.access_token; m_ban = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/ban?access_token=" + session.access_token; diff --git a/src/matrix/rest/session_urls.cpp b/src/matrix/rest/session_urls.cpp index 8ffa470..945d9de 100644 --- a/src/matrix/rest/session_urls.cpp +++ b/src/matrix/rest/session_urls.cpp @@ -19,16 +19,16 @@ #include "matrix/rest/session_urls.hpp" namespace matrix::rest::session_urls{ - raii::string login(const session_info& session){ - return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/login"); + rexy::string login(const session_info& session){ + return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/login"); } - raii::string logout(const session_info& session){ - return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/logout?access_token=" + session.access_token); + rexy::string logout(const session_info& session){ + return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/logout?access_token=" + session.access_token); } - raii::string password(const session_info& session){ - return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/account/password?access_token=" + session.access_token); + rexy::string password(const session_info& session){ + return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/account/password?access_token=" + session.access_token); } - raii::string whoami(const session_info& session){ - return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/account/whoami?access_token=" + session.access_token); + rexy::string whoami(const session_info& session){ + return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/account/whoami?access_token=" + session.access_token); } } diff --git a/src/matrix/roomcxn.cpp b/src/matrix/roomcxn.cpp index 55c61cf..24aa79d 100644 --- a/src/matrix/roomcxn.cpp +++ b/src/matrix/roomcxn.cpp @@ -17,7 +17,7 @@ */ #include "matrix/roomcxn.hpp" -#include "raii/string_base.hpp" +#include #include "matrix/fat_strings.hpp" #include "matrix/json_targets.hpp" #include "raii/util.hpp" @@ -26,23 +26,23 @@ namespace matrix{ - roomcxn::roomcxn(const std::shared_ptr& ses, const raii::string_base& roomid): - roomcxn(ses, raii::string(roomid)){} - roomcxn::roomcxn(const std::shared_ptr& ses, raii::string&& roomid): + roomcxn::roomcxn(const std::shared_ptr& ses, const rexy::string_base& roomid): + roomcxn(ses, rexy::string(roomid)){} + roomcxn::roomcxn(const std::shared_ptr& ses, rexy::string&& roomid): connection(ses), m_roomid(std::move(roomid)), m_urls(*ses, m_curl.encode(m_roomid)){} netreturn roomcxn::join(void)const{ - raii::string response = _post_curl(raii::string(), m_urls.join(*m_ses, m_roomid), raii::curl_llist()); + rexy::string response = _post_curl(rexy::string(), m_urls.join(*m_ses, m_roomid), raii::curl_llist()); return _create_netreturn(response, http_status()); } netreturn roomcxn::leave(void)const{ - raii::string response = _post_curl(raii::string(), m_urls.leave(*m_ses, m_roomid), raii::curl_llist()); + rexy::string response = _post_curl(rexy::string(), m_urls.leave(*m_ses, m_roomid), raii::curl_llist()); return _create_netreturn(response, http_status()); } netreturn roomcxn::forget(void)const{ - raii::string response = _post_curl(raii::string(), m_urls.forget(*m_ses, m_roomid), raii::curl_llist()); + rexy::string response = _post_curl(rexy::string(), m_urls.forget(*m_ses, m_roomid), raii::curl_llist()); return _create_netreturn(response, http_status()); } netreturn roomcxn::accept_invite(void)const{ @@ -55,7 +55,7 @@ namespace matrix{ netreturn> roomcxn::members(void)const{ netreturn> retval; - raii::string resp = _get_curl(m_urls.room_members()); + rexy::string resp = _get_curl(m_urls.room_members()); if(!resp) return _create_netreturn(resp, http_status()); raii::rjp_ptr root(rjp_parse(resp.get())); if(!root) return _create_netreturn(root, http_status()); @@ -69,17 +69,17 @@ namespace matrix{ } return retval; } - netreturn roomcxn::invite(const raii::string_base& userid){ - raii::string json(json::_userid(userid)); + netreturn roomcxn::invite(const rexy::string_base& userid){ + rexy::string json(json::_userid(userid)); printf("%s\n", json.get()); - raii::string response = _post_curl(json, m_urls.invite(), raii::curl_llist()); + rexy::string response = _post_curl(json, m_urls.invite(), raii::curl_llist()); return _create_netreturn(response, http_status()); } - netreturn roomcxn::uninvite(const raii::string_base& userid, const raii::string_base& reason){ + netreturn roomcxn::uninvite(const rexy::string_base& userid, const rexy::string_base& reason){ return kick(userid, reason); } - netreturn roomcxn::kick(const raii::string_base& userid, const raii::string_base& reason){ - raii::string response; + netreturn roomcxn::kick(const rexy::string_base& userid, const rexy::string_base& reason){ + rexy::string response; if(reason){ response = _post_curl(json::_userid_reason(userid, reason), m_urls.kick(), raii::curl_llist()); }else{ @@ -87,8 +87,8 @@ namespace matrix{ } return _create_netreturn(response, http_status()); } - netreturn roomcxn::ban(const raii::string_base& userid, const raii::string_base& reason){ - raii::string response; + netreturn roomcxn::ban(const rexy::string_base& userid, const rexy::string_base& reason){ + rexy::string response; if(reason){ response = _post_curl(json::_userid_reason(userid, reason), m_urls.ban(), raii::curl_llist()); }else{ @@ -96,14 +96,14 @@ namespace matrix{ } return _create_netreturn(response, http_status()); } - netreturn roomcxn::unban(const raii::string_base& userid){ - raii::string response = _post_curl(json::_userid(userid), m_urls.unban(), raii::curl_llist()); + netreturn roomcxn::unban(const rexy::string_base& userid){ + rexy::string response = _post_curl(json::_userid(userid), m_urls.unban(), raii::curl_llist()); return _create_netreturn(response, http_status()); } - netreturn roomcxn::send_custom_event(const raii::string_base& event, const raii::string_base& eventtype)const{ - raii::string reply = _post_curl(event, m_urls.send(*m_ses, m_curl.encode(m_roomid), eventtype), raii::curl_llist()); + netreturn roomcxn::send_custom_event(const rexy::string_base& event, const rexy::string_base& eventtype)const{ + rexy::string reply = _post_curl(event, m_urls.send(*m_ses, m_curl.encode(m_roomid), eventtype), raii::curl_llist()); if(!reply) return _create_netreturn(reply, http_status()); @@ -112,10 +112,10 @@ namespace matrix{ retval.value() = _curl_reply_search(root, json::keys::event::eventid()); return retval; } - netreturn roomcxn::send_message(const raii::string_base& text)const{ + netreturn roomcxn::send_message(const rexy::string_base& text)const{ return _send_message(json::_message_body(text)); } - netreturn roomcxn::send_notice(const raii::string_base& text)const{ + netreturn roomcxn::send_notice(const rexy::string_base& text)const{ return _send_message(json::_notice_body(text)); } netreturn roomcxn::send_file(const uploaded_file& file)const{ @@ -137,12 +137,12 @@ namespace matrix{ netreturn roomcxn::send_typing(bool active, int timeout)const{ return _create_netreturn(_put_curl(json::_typing(active, timeout), m_urls.typing(), raii::curl_llist()), http_status()); } - netreturn roomcxn::send_read_receipt(const raii::string_base& eventid)const{ - return _create_netreturn(_post_curl(raii::string(), m_urls.read_receipt(*m_ses, m_curl.encode(m_roomid), m_curl.encode(eventid)), raii::curl_llist()), http_status()); + netreturn roomcxn::send_read_receipt(const rexy::string_base& eventid)const{ + return _create_netreturn(_post_curl(rexy::string(), m_urls.read_receipt(*m_ses, m_curl.encode(m_roomid), m_curl.encode(eventid)), raii::curl_llist()), http_status()); } - netreturn roomcxn::get_event(const raii::string_base& eventid)const{ - raii::string reply = _get_curl(m_urls.event(*m_ses, m_curl.encode(m_roomid), eventid)); + netreturn roomcxn::get_event(const rexy::string_base& eventid)const{ + rexy::string reply = _get_curl(m_urls.event(*m_ses, m_curl.encode(m_roomid), eventid)); if(!reply) return _create_netreturn(reply, http_status()); raii::rjp_ptr root(rjp_parse(reply.get())); if(!root.get()) _create_netreturn(root, http_status()); @@ -151,14 +151,14 @@ namespace matrix{ retval.value() = sync::roomcxn_message_event_list(root, root.get(), m_roomid); return retval; } - netreturn roomcxn::redact_event(const raii::string_base& eventid, const raii::string_base& reason)const{ + netreturn roomcxn::redact_event(const rexy::string_base& eventid, const rexy::string_base& reason)const{ return _put_and_find(json::_redact(reason), m_urls.redact(*m_ses, m_curl.encode(m_roomid), m_curl.encode(eventid)), raii::curl_llist(), json::keys::event::eventid()); } - netreturn roomcxn::redact_event(const raii::string_base& eventid)const{ + netreturn roomcxn::redact_event(const rexy::string_base& eventid)const{ return redact_event(eventid, "No reason given"_ss); } - netreturn roomcxn::_get_events(int amount, raii::static_string direction, const raii::string_base& from, const raii::string_base& to){ - raii::string reply = _get_curl(m_urls.messages(*m_ses, m_curl.encode(m_roomid), from, to, direction, amount)); + netreturn roomcxn::_get_events(int amount, rexy::static_string direction, const rexy::string_base& from, const rexy::string_base& to){ + rexy::string reply = _get_curl(m_urls.messages(*m_ses, m_curl.encode(m_roomid), from, to, direction, amount)); if(!reply) return _create_netreturn(reply, http_status()); raii::rjp_ptr root(rjp_parse(reply.get())); if(!root.get()) _create_netreturn(root, http_status()); @@ -171,15 +171,15 @@ namespace matrix{ return retval; } netreturn roomcxn::get_events_forward(int amount){ - return _get_events(amount, "f"_ss, raii::string(), raii::string()); + return _get_events(amount, "f"_ss, rexy::string(), rexy::string()); } netreturn roomcxn::get_events_backward(int amount){ - return _get_events(amount, "b"_ss, raii::string(), raii::string()); + return _get_events(amount, "b"_ss, rexy::string(), rexy::string()); } - netreturn roomcxn::get_events_forward(int amount, const raii::string_base& from, const raii::string_base& to){ + netreturn roomcxn::get_events_forward(int amount, const rexy::string_base& from, const rexy::string_base& to){ return _get_events(amount, "f"_ss, from, to); } - netreturn roomcxn::get_events_backward(int amount, const raii::string_base& from, const raii::string_base& to){ + netreturn roomcxn::get_events_backward(int amount, const rexy::string_base& from, const rexy::string_base& to){ return _get_events(amount, "b"_ss, from, to); } @@ -190,7 +190,7 @@ namespace matrix{ return _post_and_find(json::_room_upgrade(version), m_urls.upgrade(*m_ses, m_roomid), raii::curl_llist(), json::keys::event::eventid()); } - netreturn roomcxn::_send_message(const raii::string_base& msg)const{ + netreturn roomcxn::_send_message(const rexy::string_base& msg)const{ return send_custom_event(msg, "m.room.message"_ss); } } diff --git a/src/matrix/session.cpp b/src/matrix/session.cpp index a172a3b..2806dab 100644 --- a/src/matrix/session.cpp +++ b/src/matrix/session.cpp @@ -20,15 +20,15 @@ #include "raii/rjp_ptr.hpp" #include "raii/curler.hpp" #include "raii/util.hpp" -#include "raii/string_base.hpp" +#include #include "matrix/fat_strings.hpp" #include "matrix/json_targets.hpp" #include "matrix/rest/session_urls.hpp" namespace matrix{ - static raii::string create_auth_header(const raii::string_base& token){ - return raii::string("Authorization: Bearer " + token); + static rexy::string create_auth_header(const rexy::string_base& token){ + return rexy::string("Authorization: Bearer " + token); } session::session(void): @@ -43,43 +43,43 @@ namespace matrix{ invalidate(); } - void session::set_useragent(const raii::string_base& agent){ + void session::set_useragent(const rexy::string_base& agent){ m_ses->useragent = agent; } - void session::set_useragent(raii::string&& agent){ + void session::set_useragent(rexy::string&& agent){ m_ses->useragent = std::move(agent); } - void session::set_homeserver(const raii::string_base& hs){ + void session::set_homeserver(const rexy::string_base& hs){ m_ses->homeserver = hs; } - void session::set_homeserver(raii::string&& hs){ + void session::set_homeserver(rexy::string&& hs){ m_ses->homeserver = std::move(hs); } - void session::set_access_token(const raii::string_base& tok){ + void session::set_access_token(const rexy::string_base& tok){ m_ses->access_token = tok; m_ses->auth_header = create_auth_header(m_ses->access_token); } - void session::set_access_token(raii::string&& tok){ + void session::set_access_token(rexy::string&& tok){ m_ses->access_token = std::move(tok); m_ses->auth_header = create_auth_header(m_ses->access_token); } netreturn session::login(void){ - return _do_login(raii::string(), raii::string()); + return _do_login(rexy::string(), rexy::string()); } - netreturn session::login(const raii::string_base& username, const raii::string_base& pass){ + netreturn session::login(const rexy::string_base& username, const rexy::string_base& pass){ return _do_login(username, pass); } netreturn session::logout(void){ - raii::string reply = _post_curl(raii::string(), rest::session_urls::logout(*m_ses), raii::curl_llist()); + rexy::string reply = _post_curl(rexy::string(), rest::session_urls::logout(*m_ses), raii::curl_llist()); return _create_netreturn(reply, http_status()); } bool session::valid(void)const{ return m_valid; } - netreturn session::change_password(const raii::string_base& oldpass, const raii::string_base& newpass){ - raii::string reply = _post_curl(json::_empty(), rest::session_urls::password(*m_ses), raii::curl_llist()); + netreturn session::change_password(const rexy::string_base& oldpass, const rexy::string_base& newpass){ + rexy::string reply = _post_curl(json::_empty(), rest::session_urls::password(*m_ses), raii::curl_llist()); if(!reply) return _create_netreturn(reply, http_status()); raii::rjp_ptr root(rjp_parse(reply)); @@ -89,7 +89,7 @@ namespace matrix{ //attempt to change password via username/password login RJP_value* res = rjp_search_member(root.get(), json::keys::session()); - raii::string request = json::_change_psk_password(m_ses->userid, newpass, oldpass, raii::rjp_string(res)); + rexy::string request = json::_change_psk_password(m_ses->userid, newpass, oldpass, raii::rjp_string(res)); reply = _post_curl(request, rest::session_urls::password(*m_ses), raii::curl_llist()); return _create_netreturn(reply, http_status()); } @@ -104,7 +104,7 @@ namespace matrix{ m_ses->userid.reset(); } - netreturn session::_do_login(const raii::string_base& username, const raii::string_base& pass){ + netreturn session::_do_login(const rexy::string_base& username, const rexy::string_base& pass){ auto reply = _get_curl(rest::session_urls::whoami(*m_ses)); netreturn retval = _create_netreturn(reply, http_status()); if(!retval.ok()){ @@ -143,16 +143,16 @@ namespace matrix{ m_ses->auth_header = create_auth_header(m_ses->access_token); _do_login(a.name, a.pass); } - raii::string session::_request_access_token(const raii::string_base& name, const raii::string_base& pass, const raii::string_base& loginurl)const{ - raii::string postdata = json::_login_password(name, pass); - raii::string reply = _post_curl(postdata, loginurl, raii::curl_llist{}); + rexy::string session::_request_access_token(const rexy::string_base& name, const rexy::string_base& pass, const rexy::string_base& loginurl)const{ + rexy::string postdata = json::_login_password(name, pass); + rexy::string reply = _post_curl(postdata, loginurl, raii::curl_llist{}); return reply; } netreturn session::_get_userid(void){ return _get_and_find(rest::session_urls::whoami(*m_ses), json::keys::auth::userid()); } - netreturn> session::_get_new_access_token(const raii::string_base& name, const raii::string_base& pass, const raii::string_base& loginurl){ - raii::string reply = _request_access_token(name, pass, loginurl); + netreturn> session::_get_new_access_token(const rexy::string_base& name, const rexy::string_base& pass, const rexy::string_base& loginurl){ + rexy::string reply = _request_access_token(name, pass, loginurl); if(!reply) return _create_netreturn(reply, http_status()); raii::rjp_ptr root(rjp_parse(reply)); diff --git a/src/matrix/sync_response.cpp b/src/matrix/sync_response.cpp index 36930a2..f31b165 100644 --- a/src/matrix/sync_response.cpp +++ b/src/matrix/sync_response.cpp @@ -21,8 +21,8 @@ namespace matrix::sync{ //Room event response - raii::static_string room_event_response::roomid(void)const{ - return raii::static_string(rjp_member_key(m_room)->value, rjp_member_key(m_room)->length); + rexy::static_string room_event_response::roomid(void)const{ + return rexy::static_string(rjp_member_key(m_room)->value, rjp_member_key(m_room)->length); } RJP_value* room_event_response::_find_event_list(const char* mname)const{ RJP_value* res = rjp_search_member(m_room, mname); @@ -50,7 +50,7 @@ namespace matrix::sync{ } //Sync response - client_response::client_response(const raii::string_base& s): + client_response::client_response(const rexy::string_base& s): m_root(rjp_parse(s)){} client_response::client_response(RJP_value* root): m_root(root){} @@ -66,10 +66,10 @@ namespace matrix::sync{ device_list client_response::device_lists(void)const{ return rjp_search_member(m_root.get(), "device_lists"); } - raii::static_string client_response::next_batch(void)const&{ + rexy::static_string client_response::next_batch(void)const&{ RJP_value* nb = rjp_search_member(m_root.get(), "next_batch"); if(!nb) return {}; - return raii::static_string(rjp_get_cstring(nb)->value, rjp_get_cstring(nb)->length); + return rexy::static_string(rjp_get_cstring(nb)->value, rjp_get_cstring(nb)->length); } raii::rjp_string client_response::next_batch(void)&&{ return raii::rjp_string(rjp_search_member(m_root.get(), "next_batch")); diff --git a/src/raii/binary.cpp b/src/raii/binary.cpp deleted file mode 100644 index 7a3b1af..0000000 --- a/src/raii/binary.cpp +++ /dev/null @@ -1,37 +0,0 @@ -/** - This file is a part of rexy's matrix client - Copyright (C) 2019-2020 rexy712 - - This program 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. - - This program 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 this program. If not, see . -*/ - -#include "raii/binary.hpp" - -namespace raii{ - - binary_base::binary_base(binary_base&& b): - m_data(std::exchange(b.m_data, nullptr)), - m_size(b.m_size), - m_cap(b.m_cap){} - - char* binary_base::release(void){ - return std::exchange(m_data, nullptr); - } - char& binary_base::operator[](size_t i){ - return m_data[i]; - } - const char& binary_base::operator[](size_t i)const{ - return m_data[i]; - } -} diff --git a/src/raii/curler.cpp b/src/raii/curler.cpp index caa0d7e..fe0ce9b 100644 --- a/src/raii/curler.cpp +++ b/src/raii/curler.cpp @@ -62,19 +62,19 @@ namespace raii{ curler& curler::seturl(const char* s){ return setopt(CURLOPT_URL, s); } - curler& curler::seturl(const string_base& s){ + curler& curler::seturl(const rexy::string_base& s){ return seturl(s.get()); } curler& curler::setuseragent(const char* s){ return setopt(CURLOPT_USERAGENT, s); } - curler& curler::setuseragent(const string_base& s){ + curler& curler::setuseragent(const rexy::string_base& s){ return setuseragent(s.get()); } curler& curler::setuserpwd(const char* s){ return setopt(CURLOPT_USERPWD, s); } - curler& curler::setuserpwd(const string_base& s){ + curler& curler::setuserpwd(const rexy::string_base& s){ return setuserpwd(s.get()); } curler& curler::setpostdata(const char* s, curl_off_t len){ @@ -82,7 +82,7 @@ namespace raii{ setopt(CURLOPT_POSTFIELDSIZE_LARGE, len); return *this; } - curler& curler::setpostdata(const string_base& s){ + curler& curler::setpostdata(const rexy::string_base& s){ setpostdata(s.get(), s.length()); return *this; } diff --git a/src/raii/filerd.cpp b/src/raii/filerd.cpp deleted file mode 100644 index 315e285..0000000 --- a/src/raii/filerd.cpp +++ /dev/null @@ -1,112 +0,0 @@ -/** - This file is a part of rexy's matrix client - Copyright (C) 2019-2020 rexy712 - - This program 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. - - This program 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 this program. If not, see . -*/ - -#include "raii/filerd.hpp" - -#include //fopen, fclose -#include //exchange, swap - -namespace raii{ - - filerd::filerd(const char* f, const char* mode): - m_fp(fopen(f, mode)){} - filerd::filerd(filerd&& f): - m_fp(std::exchange(f.m_fp, nullptr)){} - filerd::~filerd(void){ - if(m_fp) - fclose(m_fp); - } - filerd& filerd::operator=(filerd&& f){ - std::swap(m_fp, f.m_fp); - return *this; - } - - void filerd::reset(FILE* fp){ - if(m_fp) - fclose(m_fp); - m_fp = fp; - } - FILE* filerd::release(void){ - return std::exchange(m_fp, nullptr); - } - size_t filerd::length(void){ - if(!m_fp) - return 0; - size_t tmp, ret; - tmp = ftell(m_fp); - fseek(m_fp, 0, SEEK_END); - ret = ftell(m_fp); - fseek(m_fp, tmp, SEEK_SET); - return ret; - } - size_t filerd::position(void)const{ - return ftell(m_fp); - } - void filerd::rewind(size_t pos){ - fseek(m_fp, pos, SEEK_SET); - } - - filerd::operator FILE*(void){ - return m_fp; - } - filerd::operator const FILE*(void)const{ - return m_fp; - } - FILE* filerd::get(void){ - return m_fp; - } - const FILE* filerd::get(void)const{ - return m_fp; - } - filerd::operator bool(void)const{ - return m_fp; - } - - size_t filerd::read(char* dest, size_t bytes){ - return fread(dest, 1, bytes, m_fp); - } - raii::string filerd::read(size_t bytes){ - char* tmp = reinterpret_cast(raii::string::allocator_type::allocate(bytes)); - size_t written = read(tmp, bytes); - return raii::string(tmp, written); - } - raii::string filerd::readln(size_t max){ - raii::string ret; - char c; - size_t count = 0; - for(c = fgetc(m_fp);c != EOF && c != '\n';c = fgetc(m_fp)){ - ret.append(&c, 1); - if(++count == max) - break; - } - return ret; - } - raii::binary filerd::read_bin(size_t bytes){ - char* tmp = reinterpret_cast(raii::binary::allocator_type::allocate(bytes)); - size_t written = read(tmp, bytes); - return raii::binary(tmp, written, written); - } - size_t filerd::write(const char* c, size_t bytes){ - return fwrite(c, 1, bytes, m_fp); - } - size_t filerd::write(const raii::string_base& c){ - return write(c.get(), c.length()); - } - -} - diff --git a/src/raii/string_base.cpp b/src/raii/string_base.cpp deleted file mode 100644 index 69aa27a..0000000 --- a/src/raii/string_base.cpp +++ /dev/null @@ -1,49 +0,0 @@ -/** - This file is a part of rexy's matrix client - Copyright (C) 2019-2020 rexy712 - - This program 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. - - This program 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 this program. If not, see . -*/ - -#include "raii/string_base.hpp" - -#include //exchange, swap -#include //memcpy -#include //strcpy, strlen - -namespace raii{ - char* string_base::release(void){ - return std::exchange(m_data, nullptr); - } - char& string_base::operator[](size_t i){ - return m_data[i]; - } - const char& string_base::operator[](size_t i)const{ - return m_data[i]; - } - - static_string::static_string(const char* c): - static_string(const_cast(c), strlen(c)){} - static_string& static_string::operator=(const char* c){ - m_data = const_cast(c); - m_length = strlen(c); - return *this; - } - static_string& static_string::operator=(const static_string& s){ - m_data = s.m_data; - m_length = s.m_length; - return *this; - } - -} diff --git a/src/raii/util.cpp b/src/raii/util.cpp index cc3e8b1..5ba05fb 100644 --- a/src/raii/util.cpp +++ b/src/raii/util.cpp @@ -16,7 +16,7 @@ along with this program. If not, see . */ -#include "raii/string.hpp" +#include namespace raii{ @@ -82,12 +82,12 @@ namespace raii{ return pos; } } - string json_escape(const string_base& str){ + rexy::string json_escape(const rexy::string_base& str){ size_t len = detail::_calc_escaped_len(str.get()); - char* tmp = reinterpret_cast(string::allocator_type::allocate(len+1)); + char* tmp = reinterpret_cast(rexy::string::allocator_type::allocate(len+1)); detail::_sanitize_json_copy(tmp, str); tmp[len] = 0; - return string(tmp, len, len); + return rexy::string(tmp, len, len); } @@ -112,11 +112,11 @@ namespace raii{ } } } - raii::string itostr(int i){ + rexy::string itostr(int i){ if(i == 0) - return raii::string("0"); + return rexy::string("0"); int place = intlen(i); - raii::string ret(place, place); + rexy::string ret(place, place); char* buf = ret.get(); buf[place] = 0; while(i != 0){ diff --git a/src/test.cpp b/src/test.cpp index e68d29a..5130224 100644 --- a/src/test.cpp +++ b/src/test.cpp @@ -19,11 +19,12 @@ //example of a client which responds to commands #include "matrix/matrix.hpp" -#include "raii/string_base.hpp" +#include #include "matrix/sync_response.hpp" #include "raii/util.hpp" #include "matrix/json_targets.hpp" #include "matrix/events.hpp" +#include #include #include @@ -32,7 +33,7 @@ #include matrix::auth_data read_auth_file(const char* filename){ - raii::filerd fp(filename, "r"); + rexy::filerd fp(filename, "r"); if(!fp){ return {}; } @@ -61,7 +62,7 @@ void write_to_auth_file(const char* filename, const matrix::auth_data& auth){ raii::rjp_string output; output.reset(rjp_to_json(root.get(), RJP_FORMAT_NONE)); - raii::filerd fp(filename, "w"); + rexy::filerd fp(filename, "w"); if(!fp) return; fp.write(output); @@ -85,7 +86,7 @@ matrix::session login_to_homeserver(void){ } struct command{ - raii::static_string command_name; + rexy::static_string command_name; void(*command_exec)(const matrix::client&, const matrix::roomcxn&, const matrix::sync::room_message_event&); }; @@ -123,8 +124,8 @@ void do_help(const matrix::client&, const matrix::roomcxn& room, const matrix::s } void do_gaben(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event& event){ if(event.body().length() > 6){ - raii::static_string args = event.body().get() + 7; - room.send_message(raii::string(args + " can suck my ass"_ss)); + rexy::static_string args = event.body().get() + 7; + room.send_message(rexy::string(args + " can suck my ass"_ss)); }else{ room.send_notice("can suck my ass"_ss); } @@ -139,11 +140,11 @@ void do_emacs(const matrix::client&, const matrix::roomcxn& room, const matrix:: room.send_notice("Unfortunately, the matrix spec has no official way to forward messages. As such, riot will not interpret me sending custom forwarded events correctly. Will update when it is in the spec."_ss); } void do_nipple(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event&){ - raii::static_string str = R"({"msgtype":"m.image","body":"image.jpeg","url":"mxc://rexy712.chickenkiller.com/tmvjkYZYuhfjtMpfQcurSakd","info":{"mimetype":"image/jpeg","size":40202,"h":402,"w":512,"orientation":0}})"_ss; + rexy::static_string str = R"({"msgtype":"m.image","body":"image.jpeg","url":"mxc://rexy712.chickenkiller.com/tmvjkYZYuhfjtMpfQcurSakd","info":{"mimetype":"image/jpeg","size":40202,"h":402,"w":512,"orientation":0}})"_ss; room.send_custom_event(str, "m.room.message"_ss); } -raii::string get_command_output(const raii::string_base& command){ - raii::string result; +rexy::string get_command_output(const rexy::string_base& command){ + rexy::string result; FILE* pipe = popen(command.get(), "r"); if(!pipe) return {}; @@ -157,11 +158,11 @@ raii::string get_command_output(const raii::string_base& command){ } void do_ddate(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event& event){ - raii::string str = get_command_output(raii::static_string(event.body().get()+1)); + rexy::string str = get_command_output(rexy::static_string(event.body().get()+1)); room.send_notice(str); } -int roll_func(const raii::string_base& args, int& returnval){ +int roll_func(const rexy::string_base& args, int& returnval){ int state = 0; int diecount = 1; int sidecount = 100; @@ -239,7 +240,7 @@ int roll_func(const raii::string_base& args, int& returnval){ void do_roll(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event& event){ int rollval; if(event.body().length() > 5){ - if(roll_func(raii::static_string(event.body().get()+6), rollval)) + if(roll_func(rexy::static_string(event.body().get()+6), rollval)) return; }else{ if(roll_func(""_ss, rollval)) @@ -253,7 +254,7 @@ void do_test(const matrix::client&, const matrix::roomcxn& room, const matrix::s } void do_weebrules(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event&){ - raii::static_string rules = + rexy::static_string rules = "1.) Can't exclude without watching >=2 episodes\n" "2.) Have to respect the role unless\n a.) it's not anime night\n b.) already seen >=3 episodes\n" "3.) r0nk complaining shall be redirected into /dev/null\n" @@ -273,7 +274,7 @@ void do_cyberpunk(const matrix::client&, const matrix::roomcxn& room, const matr void do_sauce(const matrix::client& client, const matrix::roomcxn& room, const matrix::sync::room_message_event&){ matrix::file_details fd; fd.name = "src/test.cpp"_ss; - raii::filerd fp(fd.name); + rexy::filerd fp(fd.name); if(!fp){ printf("fopen error\n"); return; @@ -322,12 +323,12 @@ void handle_command(const matrix::client& client, const matrix::roomcxn& room, c } } -raii::string get_showinfo(const raii::string_base& file, const raii::string_base& show){ - raii::filerd fp(file); +rexy::string get_showinfo(const rexy::string_base& file, const rexy::string_base& show){ + rexy::filerd fp(file); if(!fp) return {}; - raii::string line; + rexy::string line; for(line = fp.readln();line.length();line = fp.readln()){ if(!strncmp(line, show, show.length()) && line[show.length()] == ':') return line;