rexy712/matrix_thing
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Start removing raii components into separate library. Strings, binary, and filerd were first to go

Browse Source
This commit is contained in:
rexy712 2020-03-02 17:09:38 -08:00
parent 22cadb1695
commit 41b976bd6a
46 changed files with 634 additions and 1764 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
include/matrix/auth.hpp
View File

@ -24,11 +24,11 @@
namespace matrix{ namespace matrix{
struct auth_data{ struct auth_data{
raii::string name; rexy::string name;
raii::string pass; rexy::string pass;
raii::string homeserver; rexy::string homeserver;
raii::string useragent; rexy::string useragent;
raii::string access_token; rexy::string access_token;
operator bool(void)const{ operator bool(void)const{
return (name && pass && homeserver); return (name && pass && homeserver);

29
include/matrix/client.hpp
View File

@ -19,9 +19,8 @@
#ifndef MATRIX_CLIENT_HPP #ifndef MATRIX_CLIENT_HPP
#define MATRIX_CLIENT_HPP #define MATRIX_CLIENT_HPP
#include "raii/string.hpp" #include <rexy/string.hpp>
#include "raii/rjp_string.hpp" #include "raii/rjp_string.hpp"
#include "raii/filerd.hpp"
#include "matrix/session_info.hpp" #include "matrix/session_info.hpp"
#include "matrix/upload_info.hpp" #include "matrix/upload_info.hpp"
#include "matrix/connection.hpp" #include "matrix/connection.hpp"
@ -58,22 +57,22 @@ namespace matrix{
* Note name must be safe to be placed in a json string. * Note name must be safe to be placed in a json string.
* Returns: true if the operation was successful. * Returns: true if the operation was successful.
*/ */
netreturn<void> set_display_name(const raii::string_base&); netreturn<void> set_display_name(const rexy::string_base&);
/* /*
* Sets the url of the user's profile picture on the homeserver. * Sets the url of the user's profile picture on the homeserver.
* Note url must be safe to be placed in a json string. * Note url must be safe to be placed in a json string.
* Returns: true if the operation was successful. * Returns: true if the operation was successful.
*/ */
netreturn<void> set_profile_picture(const raii::string_base&); netreturn<void> set_profile_picture(const rexy::string_base&);
netreturn<void> set_presence(const raii::string_base& status); netreturn<void> set_presence(const rexy::string_base& status);
netreturn<raii::rjp_string> get_presence(const raii::string_base& userid); netreturn<raii::rjp_string> get_presence(const rexy::string_base& userid);
/* /*
* Gets the display name of the logged in user from the homeserver. * Gets the display name of the logged in user from the homeserver.
* Returns: the display name on success, an empty string on failure. * Returns: the display name on success, an empty string on failure.
*/ */
netreturn<raii::rjp_string> get_display_name(void)const; netreturn<raii::rjp_string> get_display_name(void)const;
netreturn<raii::rjp_string> get_display_name(const raii::string_base&)const; netreturn<raii::rjp_string> get_display_name(const rexy::string_base&)const;
/* /*
* Gets the profile picture url of the logged in user from the homeserver. * 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. * 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. * Lookup a room id given a room alias.
* Returns: the room id of the associated room on success, empty string on failure. * Returns: the room id of the associated room on success, empty string on failure.
*/ */
netreturn<raii::rjp_string> room_alias_to_id(const raii::string_base& alias)const; netreturn<raii::rjp_string> room_alias_to_id(const rexy::string_base& alias)const;
/* /*
* Get a list of rooms the logged in user is a member of. * 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. * 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. * Returns: the room id of the newly created room on success, an empty string on failure.
*/ */
netreturn<raii::rjp_string> create_room(const raii::string_base& name, const raii::string_base& alias)const; netreturn<raii::rjp_string> create_room(const rexy::string_base& name, const rexy::string_base& alias)const;
/* /*
* Create a new matrix::roomcxn object for the given roomid. * 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. * access token, or homeserver after creating a roomcxn MUST be synchronized between threads.
* Returns: a new matrix::roomcxn for the given roomid. * Returns: a new matrix::roomcxn for the given roomid.
*/ */
roomcxn spawn_room(const raii::string_base& roomid)const; roomcxn spawn_room(const rexy::string_base& roomid)const;
roomcxn spawn_room(raii::string&& roomid)const; roomcxn spawn_room(rexy::string&& roomid)const;
//NOTE alias equivalents just give the uploaded file a name other than the filename. //NOTE alias equivalents just give the uploaded file a name other than the filename.
@ -139,9 +138,9 @@ namespace matrix{
netreturn<void> create_thumbnail(uploaded_image& info)const; netreturn<void> create_thumbnail(uploaded_image& info)const;
netreturn<void> create_thumbnail(uploaded_video& video)const; netreturn<void> 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<class DLHandler> template<class DLHandler>
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)); _get_curl_setup(m_urls->file_download(*m_ses, url));
m_curl.setwritefun(_download_dispatch<DLHandler>); m_curl.setwritefun(_download_dispatch<DLHandler>);
m_curl.setwritedata(&dl); m_curl.setwritedata(&dl);
@ -150,8 +149,8 @@ namespace matrix{
return true; return true;
} }
template<class DLHandler> template<class DLHandler>
bool download_file(const raii::string_base& server, const raii::string_base& media_id, DLHandler&& dl){ bool download_file(const rexy::string_base& server, const rexy::string_base& media_id, DLHandler&& dl){
raii::string url = "mxc://"_ss + server + "/"_ss + media_id; rexy::string url = "mxc://"_ss + server + "/"_ss + media_id;
return download_file(url, std::forward<DLHandler>(dl)); return download_file(url, std::forward<DLHandler>(dl));
} }

40
include/matrix/connection.hpp
View File

@ -20,9 +20,9 @@
#define MATRIX_CONNECTION_HPP #define MATRIX_CONNECTION_HPP
#include "raii/curler.hpp" #include "raii/curler.hpp"
#include "raii/string.hpp" #include <rexy/string.hpp>
#include "raii/rjp_string.hpp" #include "raii/rjp_string.hpp"
#include "raii/binary.hpp" #include <rexy/binary.hpp>
#include "raii/rjp_ptr.hpp" #include "raii/rjp_ptr.hpp"
#include "matrix/session_info.hpp" #include "matrix/session_info.hpp"
#include "matrix/netreturn.hpp" #include "matrix/netreturn.hpp"
@ -59,7 +59,7 @@ namespace matrix{
* NOT thread safe * NOT thread safe
* Returns: the current useragent. * 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. * 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 _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); 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 _get_curl_setup(const rexy::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 _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); 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: protected:
using binary_callback_fun = size_t(*)(char*, size_t, size_t, void*); using binary_callback_fun = size_t(*)(char*, size_t, size_t, void*);
using reply_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; bool _perform_curl(void)const;
raii::string _get_curl(const raii::string_base& url, reply_callback_fun fun = _reply_curl_callback)const; rexy::string _get_curl(const rexy::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; rexy::binary _get_curl_binary(const rexy::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; 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;
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; 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;
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; 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;
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; 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<raii::rjp_string> _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<raii::rjp_string> _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<raii::rjp_string> _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<raii::rjp_string> _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<raii::rjp_string> _get_and_find(const raii::string_base& url, const raii::string_base& search)const; netreturn<raii::rjp_string> _get_and_find(const rexy::string_base& url, const rexy::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 rexy::string_base& reply, const rexy::string_base& search)const;
raii::rjp_string _curl_reply_search(const raii::rjp_ptr& root, const raii::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 raii::string_base& useragent)const; void _set_curl_defaults(const rexy::string_base& useragent)const;
static netreturn_base _create_netreturn(const raii::string_base& mxjson, int httpstatus); static netreturn_base _create_netreturn(const rexy::string_base& mxjson, int httpstatus);
static netreturn_base _create_netreturn(const raii::rjp_ptr& root, int httpstatus); static netreturn_base _create_netreturn(const raii::rjp_ptr& root, int httpstatus);
}; };

32
include/matrix/events.hpp
View File

@ -20,7 +20,7 @@
#define MATRIX_EVENT_HPP #define MATRIX_EVENT_HPP
#include "raii/rjp_ptr.hpp" #include "raii/rjp_ptr.hpp"
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
#include "raii/rjp_string.hpp" #include "raii/rjp_string.hpp"
namespace matrix::sync{ namespace matrix::sync{
@ -42,7 +42,7 @@ namespace matrix::sync{
~event(void) = default; ~event(void) = default;
event& operator=(const event&); event& operator=(const event&);
raii::static_string type(void)const&; rexy::static_string type(void)const&;
raii::rjp_string type(void)&&; raii::rjp_string type(void)&&;
const RJP_value* content(void)const; const RJP_value* content(void)const;
RJP_value* content(void); RJP_value* content(void);
@ -57,16 +57,16 @@ namespace matrix::sync{
class room_event_base class room_event_base
{ {
protected: protected:
raii::static_string m_roomid; rexy::static_string m_roomid;
public: public:
room_event_base(void) = default; room_event_base(void) = default;
room_event_base(const room_event_base&) = delete; room_event_base(const room_event_base&) = delete;
constexpr room_event_base(room_event_base&&) = default; constexpr room_event_base(room_event_base&&) = default;
room_event_base& operator=(const 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()){} 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; return m_roomid;
} }
}; };
@ -84,22 +84,22 @@ namespace matrix::sync{
int m_origin_server_ts; int m_origin_server_ts;
public: public:
room_event(void) = default; 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(const room_event&) = delete; //TODO
room_event(room_event&&)noexcept; room_event(room_event&&)noexcept;
room_event& operator=(const room_event&) = delete; room_event& operator=(const room_event&) = delete;
room_event& operator=(room_event&&); room_event& operator=(room_event&&);
raii::static_string eventid(void)const&; rexy::static_string eventid(void)const&;
raii::rjp_string eventid(void)&&; raii::rjp_string eventid(void)&&;
raii::static_string sender(void)const&; rexy::static_string sender(void)const&;
raii::rjp_string sender(void)&&; raii::rjp_string sender(void)&&;
int origin_server_ts(void)const; int origin_server_ts(void)const;
const RJP_value* extra(void)const; const RJP_value* extra(void)const;
RJP_value* extra(void); RJP_value* extra(void);
//only for m.room.redacts events //only for m.room.redacts events
raii::static_string redacts(void)const&; rexy::static_string redacts(void)const&;
raii::rjp_string redacts(void)&&; raii::rjp_string redacts(void)&&;
}; };
@ -113,15 +113,15 @@ namespace matrix::sync{
RJP_value* m_prev_content; RJP_value* m_prev_content;
public: public:
room_state_event(void) = default; 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(const room_state_event&) = delete; //TODO
room_state_event(room_state_event&&); room_state_event(room_state_event&&);
room_state_event& operator=(const room_state_event&) = delete; room_state_event& operator=(const room_state_event&) = delete;
room_state_event& operator=(room_state_event&&); 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::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)&&; raii::rjp_string prev_content(void)&&;
}; };
@ -131,7 +131,7 @@ namespace matrix::sync{
class room_ephemeral_event : public room_event_base, public event class room_ephemeral_event : public room_event_base, public event
{ {
public: 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(const room_ephemeral_event&) = delete; //TODO
room_ephemeral_event(room_ephemeral_event&&) = default; room_ephemeral_event(room_ephemeral_event&&) = default;
}; };
@ -144,15 +144,15 @@ namespace matrix::sync{
RJP_value* m_body; RJP_value* m_body;
RJP_value* m_type; RJP_value* m_type;
public: 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(const room_message_event&) = delete;
room_message_event(room_message_event&&); room_message_event(room_message_event&&);
room_message_event(room_event&&)noexcept; room_message_event(room_event&&)noexcept;
raii::static_string body(void)const&; rexy::static_string body(void)const&;
raii::rjp_string body(void)&&; raii::rjp_string body(void)&&;
raii::static_string msgtype(void)const&; rexy::static_string msgtype(void)const&;
raii::rjp_string msgtype(void)&&; raii::rjp_string msgtype(void)&&;
}; };

38
include/matrix/fat_strings.hpp
View File

@ -24,30 +24,30 @@
//these functions should rarely change, so it will still build slowly //these functions should rarely change, so it will still build slowly
//but will rarely need rebuilt //but will rarely need rebuilt
#include "raii/string.hpp" #include <rexy/string.hpp>
#include "matrix/upload_info.hpp" #include "matrix/upload_info.hpp"
namespace matrix::json{ namespace matrix::json{
raii::static_string _empty(void); rexy::static_string _empty(void);
raii::string _image_body(const uploaded_image& image); rexy::string _image_body(const uploaded_image& image);
raii::string _video_body(const uploaded_video& video); rexy::string _video_body(const uploaded_video& video);
raii::string _file_body(const uploaded_file& video); rexy::string _file_body(const uploaded_file& video);
raii::string _audio_body(const uploaded_audio& audio); rexy::string _audio_body(const uploaded_audio& audio);
raii::string _message_body(const raii::string_base& text); rexy::string _message_body(const rexy::string_base& text);
raii::string _notice_body(const raii::string_base& msg); rexy::string _notice_body(const rexy::string_base& msg);
raii::string _login_password(const raii::string_base& userid, const raii::string_base& password); rexy::string _login_password(const rexy::string_base& userid, const rexy::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 _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); rexy::string _displayname_set(const rexy::string_base& newname);
raii::string _avatar_set(const raii::string_base& mediaurl); rexy::string _avatar_set(const rexy::string_base& mediaurl);
raii::string _presence_set(const raii::string_base& status); rexy::string _presence_set(const rexy::string_base& 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);
raii::string _userid(const raii::string_base& id); rexy::string _userid(const rexy::string_base& id);
raii::string _userid_reason(const raii::string_base& id, const raii::string_base& reason); rexy::string _userid_reason(const rexy::string_base& id, const rexy::string_base& reason);
raii::string _typing(bool active, int timeout); rexy::string _typing(bool active, int timeout);
raii::string _redact(const raii::string_base& reason); rexy::string _redact(const rexy::string_base& reason);
raii::string _room_upgrade(int version); rexy::string _room_upgrade(int version);
} }
#endif #endif

16
include/matrix/iterable.hpp
View File

@ -20,7 +20,7 @@
#define MATRIX_ITERABLE_HPP #define MATRIX_ITERABLE_HPP
#include "matrix/events.hpp" #include "matrix/events.hpp"
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
#include "raii/rjp_string.hpp" #include "raii/rjp_string.hpp"
#include "raii/rjp_iterator.hpp" #include "raii/rjp_iterator.hpp"
@ -64,11 +64,11 @@ namespace matrix::sync{
{ {
protected: protected:
raii::rjp_array_iterator m_event; raii::rjp_array_iterator m_event;
raii::static_string m_roomid; rexy::static_string m_roomid;
public: public:
constexpr room_event_iterator(void): constexpr room_event_iterator(void):
m_event(nullptr), m_roomid(){} 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){} m_event(v), m_roomid(roomid){}
constexpr room_event_iterator(const room_event_iterator& i): constexpr room_event_iterator(const room_event_iterator& i):
m_event(i.m_event), m_roomid(i.m_roomid){} m_event(i.m_event), m_roomid(i.m_roomid){}
@ -94,7 +94,7 @@ namespace matrix::sync{
constexpr T operator*(void){ constexpr T operator*(void){
return T(*m_event, m_roomid); 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; return m_roomid;
} }
}; };
@ -137,7 +137,7 @@ namespace matrix::sync{
iterator m_event; iterator m_event;
public: public:
constexpr iterable_room_event_base(void) = default; 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){} m_event(ev, roomid){}
constexpr iterable_room_event_base(const iterable_room_event_base& i): constexpr iterable_room_event_base(const iterable_room_event_base& i):
m_event(i.m_event){} m_event(i.m_event){}
@ -189,10 +189,10 @@ namespace matrix::sync{
raii::rjp_ptr m_root; raii::rjp_ptr m_root;
public: public:
constexpr roomcxn_event_list_base(void) = default; constexpr roomcxn_event_list_base(void) = default;
roomcxn_event_list_base(raii::rjp_ptr& root, RJP_value* event, const raii::string_base& roomid); roomcxn_event_list_base(raii::rjp_ptr& root, RJP_value* event, const rexy::string_base& roomid);
raii::static_string start_token(void)const&; rexy::static_string start_token(void)const&;
raii::rjp_string start_token(void)&&; 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)&&; raii::rjp_string end_token(void)&&;
}; };
extern template class roomcxn_event_list_base<room_state_event>; extern template class roomcxn_event_list_base<room_state_event>;

300
include/matrix/json_targets.hpp
View File

@ -1,97 +1,97 @@
#ifndef MATRIX_JSON_TARGETS_HPP #ifndef MATRIX_JSON_TARGETS_HPP
#define MATRIX_JSON_TARGETS_HPP #define MATRIX_JSON_TARGETS_HPP
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
namespace matrix::json{ namespace matrix::json{
constexpr raii::static_string True(void){return "true"_ss;} constexpr rexy::static_string True(void){return "true"_ss;}
constexpr raii::static_string False(void){return "false"_ss;} constexpr rexy::static_string False(void){return "false"_ss;}
constexpr raii::static_string reason(void){return "reason"_ss;} constexpr rexy::static_string reason(void){return "reason"_ss;}
namespace keys{ namespace keys{
constexpr raii::static_string error(void){return "error"_ss;} constexpr rexy::static_string error(void){return "error"_ss;}
constexpr raii::static_string errcode(void){return "errcode"_ss;} constexpr rexy::static_string errcode(void){return "errcode"_ss;}
constexpr raii::static_string retry_after(void){return "retry_after_ms"_ss;} constexpr rexy::static_string retry_after(void){return "retry_after_ms"_ss;}
constexpr raii::static_string joined(void){return "joined"_ss;} constexpr rexy::static_string joined(void){return "joined"_ss;}
constexpr raii::static_string chunk(void){return "chunk"_ss;} constexpr rexy::static_string chunk(void){return "chunk"_ss;}
constexpr raii::static_string newversion(void){return "new_version"_ss;} constexpr rexy::static_string newversion(void){return "new_version"_ss;}
constexpr raii::static_string presence(void){return "presence"_ss;} constexpr rexy::static_string presence(void){return "presence"_ss;}
constexpr raii::static_string displayname(void){return "displayname"_ss;} constexpr rexy::static_string displayname(void){return "displayname"_ss;}
constexpr raii::static_string avatarurl(void){return "avatar_url"_ss;} constexpr rexy::static_string avatarurl(void){return "avatar_url"_ss;}
constexpr raii::static_string joinedrooms(void){return "joined_rooms"_ss;} constexpr rexy::static_string joinedrooms(void){return "joined_rooms"_ss;}
constexpr raii::static_string contenturi(void){return "content_uri"_ss;} constexpr rexy::static_string contenturi(void){return "content_uri"_ss;}
constexpr raii::static_string name(void){return "name"_ss;} constexpr rexy::static_string name(void){return "name"_ss;}
constexpr raii::static_string roomaliasname(void){return "room_alias_name"_ss;} constexpr rexy::static_string roomaliasname(void){return "room_alias_name"_ss;}
constexpr raii::static_string typing(void){return "typing"_ss;} constexpr rexy::static_string typing(void){return "typing"_ss;}
constexpr raii::static_string timeout(void){return "timeout"_ss;} constexpr rexy::static_string timeout(void){return "timeout"_ss;}
constexpr raii::static_string session(void){return "session"_ss;} constexpr rexy::static_string session(void){return "session"_ss;}
namespace event{ namespace event{
constexpr raii::static_string type(void){return "type"_ss;} constexpr rexy::static_string type(void){return "type"_ss;}
constexpr raii::static_string content(void){return "content"_ss;} constexpr rexy::static_string content(void){return "content"_ss;}
constexpr raii::static_string eventid(void){return "event_id"_ss;} constexpr rexy::static_string eventid(void){return "event_id"_ss;}
constexpr raii::static_string sender(void){return "sender"_ss;} constexpr rexy::static_string sender(void){return "sender"_ss;}
constexpr raii::static_string origin_server_ts(void){return "origin_server_ts"_ss;} constexpr rexy::static_string origin_server_ts(void){return "origin_server_ts"_ss;}
constexpr raii::static_string roomid(void){return "room_id"_ss;} constexpr rexy::static_string roomid(void){return "room_id"_ss;}
constexpr raii::static_string extra(void){return "unsigned"_ss;} constexpr rexy::static_string extra(void){return "unsigned"_ss;}
constexpr raii::static_string state_key(void){return "state_key"_ss;} constexpr rexy::static_string state_key(void){return "state_key"_ss;}
constexpr raii::static_string prev_content(void){return "prev_content"_ss;} constexpr rexy::static_string prev_content(void){return "prev_content"_ss;}
constexpr raii::static_string redacts(void){return "redacts"_ss;} constexpr rexy::static_string redacts(void){return "redacts"_ss;}
namespace contentbody{ namespace contentbody{
constexpr raii::static_string body(void){return "body"_ss;} constexpr rexy::static_string body(void){return "body"_ss;}
constexpr raii::static_string info(void){return "info"_ss;} constexpr rexy::static_string info(void){return "info"_ss;}
namespace infobody{ namespace infobody{
constexpr raii::static_string height(void){return "h"_ss;} constexpr rexy::static_string height(void){return "h"_ss;}
constexpr raii::static_string width(void){return "w"_ss;} constexpr rexy::static_string width(void){return "w"_ss;}
constexpr raii::static_string mimetype(void){return "mimetype"_ss;} constexpr rexy::static_string mimetype(void){return "mimetype"_ss;}
constexpr raii::static_string size(void){return "size"_ss;} constexpr rexy::static_string size(void){return "size"_ss;}
constexpr raii::static_string thumbinfo(void){return "thumbnail_info"_ss;} constexpr rexy::static_string thumbinfo(void){return "thumbnail_info"_ss;}
namespace thumbnail{ namespace thumbnail{
constexpr raii::static_string height(void){return infobody::height();} constexpr rexy::static_string height(void){return infobody::height();}
constexpr raii::static_string width(void){return infobody::width();} constexpr rexy::static_string width(void){return infobody::width();}
constexpr raii::static_string mimetype(void){return infobody::mimetype();} constexpr rexy::static_string mimetype(void){return infobody::mimetype();}
constexpr raii::static_string size(void){return infobody::size();} 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 rexy::static_string msgtype(void){return "msgtype"_ss;}
constexpr raii::static_string url(void){return "url"_ss;} constexpr rexy::static_string url(void){return "url"_ss;}
} }
} }
namespace auth{ namespace auth{
constexpr raii::static_string type(void){return event::type();} constexpr rexy::static_string type(void){return event::type();}
constexpr raii::static_string medium(void){return "medium"_ss;} constexpr rexy::static_string medium(void){return "medium"_ss;}
constexpr raii::static_string address(void){return "address"_ss;} constexpr rexy::static_string address(void){return "address"_ss;}
constexpr raii::static_string identifier(void){return "identifier"_ss;} constexpr rexy::static_string identifier(void){return "identifier"_ss;}
constexpr raii::static_string user(void){return "user"_ss;} constexpr rexy::static_string user(void){return "user"_ss;}
constexpr raii::static_string password(void){return "password"_ss;} constexpr rexy::static_string password(void){return "password"_ss;}
constexpr raii::static_string token(void){return "token"_ss;} constexpr rexy::static_string token(void){return "token"_ss;}
constexpr raii::static_string device_id(void){return "device_id"_ss;} constexpr rexy::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 rexy::static_string initial_device_display_name(void){return "initial_device_display_name"_ss;}
constexpr raii::static_string newpassword(void){return "new_password"_ss;} constexpr rexy::static_string newpassword(void){return "new_password"_ss;}
constexpr raii::static_string auth(void){return "auth"_ss;} constexpr rexy::static_string auth(void){return "auth"_ss;}
constexpr raii::static_string userid(void){return "user_id"_ss;} constexpr rexy::static_string userid(void){return "user_id"_ss;}
constexpr raii::static_string accesstoken(void){return "access_token"_ss;} constexpr rexy::static_string accesstoken(void){return "access_token"_ss;}
constexpr raii::static_string home_server(void){return "home_server"_ss;} constexpr rexy::static_string home_server(void){return "home_server"_ss;}
constexpr raii::static_string well_known(void){return "well_known"_ss;} constexpr rexy::static_string well_known(void){return "well_known"_ss;}
constexpr raii::static_string base_url(void){return "base_url"_ss;} constexpr rexy::static_string base_url(void){return "base_url"_ss;}
constexpr raii::static_string inhibit_login(void){return "inhibit_login"_ss;} constexpr rexy::static_string inhibit_login(void){return "inhibit_login"_ss;}
namespace authbody{ namespace authbody{
constexpr raii::static_string type(void){return auth::type();} constexpr rexy::static_string type(void){return auth::type();}
constexpr raii::static_string session(void){return "session"_ss;} constexpr rexy::static_string session(void){return "session"_ss;}
constexpr raii::static_string user(void){return auth::user();} constexpr rexy::static_string user(void){return auth::user();}
constexpr raii::static_string password(void){return auth::password();} constexpr rexy::static_string password(void){return auth::password();}
} }
namespace identifierbody{ namespace identifierbody{
constexpr raii::static_string type(void){return auth::type();} constexpr rexy::static_string type(void){return auth::type();}
constexpr raii::static_string medium(void){return auth::medium();} constexpr rexy::static_string medium(void){return auth::medium();}
constexpr raii::static_string address(void){return auth::address();} constexpr rexy::static_string address(void){return auth::address();}
constexpr raii::static_string session(void){return auth::authbody::session();} constexpr rexy::static_string session(void){return auth::authbody::session();}
constexpr raii::static_string user(void){return auth::authbody::user();} constexpr rexy::static_string user(void){return auth::authbody::user();}
constexpr raii::static_string password(void){return auth::password();} constexpr rexy::static_string password(void){return auth::password();}
} }
} }
} }
@ -99,101 +99,101 @@ namespace matrix::json{
} }
namespace events{ namespace events{
constexpr raii::static_string homeserver(void){return "m.homeserver"_ss;} constexpr rexy::static_string homeserver(void){return "m.homeserver"_ss;}
constexpr raii::static_string identity_server(void){return "m.identity_server"_ss;} constexpr rexy::static_string identity_server(void){return "m.identity_server"_ss;}
constexpr raii::static_string presence(void){return "m.presence"_ss;} constexpr rexy::static_string presence(void){return "m.presence"_ss;}
constexpr raii::static_string direct(void){return "m.direct"_ss;} constexpr rexy::static_string direct(void){return "m.direct"_ss;}
constexpr raii::static_string ignored_user_list(void){return "m.ignored_user_list"_ss;} constexpr rexy::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 rexy::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 invited_member_count(void){return "m.invited_member_count"_ss;}
namespace key{ namespace key{
constexpr raii::static_string verification_request(void){return "m.key.verification.request"_ss;} constexpr rexy::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 rexy::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 rexy::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 rexy::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 rexy::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_mac(void){return "m.key.verification.mac"_ss;}
} }
namespace login{ namespace login{
constexpr raii::static_string password(void){return "m.login.password"_ss;} constexpr rexy::static_string password(void){return "m.login.password"_ss;}
constexpr raii::static_string recaptcha(void){return "m.login.recaptcha"_ss;} constexpr rexy::static_string recaptcha(void){return "m.login.recaptcha"_ss;}
constexpr raii::static_string oauth2(void){return "m.login.oauth2"_ss;} constexpr rexy::static_string oauth2(void){return "m.login.oauth2"_ss;}
constexpr raii::static_string email(void){return "m.login.email.identity"_ss;} constexpr rexy::static_string email(void){return "m.login.email.identity"_ss;}
constexpr raii::static_string msisdn(void){return "m.login.msisdn"_ss;} constexpr rexy::static_string msisdn(void){return "m.login.msisdn"_ss;}
constexpr raii::static_string token(void){return "m.login.token"_ss;} constexpr rexy::static_string token(void){return "m.login.token"_ss;}
constexpr raii::static_string dummy(void){return "m.login.dummy"_ss;} constexpr rexy::static_string dummy(void){return "m.login.dummy"_ss;}
} }
namespace id{ namespace id{
constexpr raii::static_string user(void){return "m.id.user"_ss;} constexpr rexy::static_string user(void){return "m.id.user"_ss;}
constexpr raii::static_string thirdparty(void){return "m.id.thirdparty"_ss;} constexpr rexy::static_string thirdparty(void){return "m.id.thirdparty"_ss;}
constexpr raii::static_string phone(void){return "m.id.phone"_ss;} constexpr rexy::static_string phone(void){return "m.id.phone"_ss;}
} }
namespace rule{ namespace rule{
constexpr raii::static_string rules(void){return "m.push_rules"_ss;} constexpr rexy::static_string rules(void){return "m.push_rules"_ss;}
constexpr raii::static_string master(void){return ".m.rule.master"_ss;} constexpr rexy::static_string master(void){return ".m.rule.master"_ss;}
constexpr raii::static_string suppress_notices(void){return ".m.rule.suppress_notices"_ss;} constexpr rexy::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 rexy::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 rexy::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 rexy::static_string contains_displayname(void){return ".m.rule.contains_display_name"_ss;}
constexpr raii::static_string tombstone(void){return ".m.rule.tombstone"_ss;} constexpr rexy::static_string tombstone(void){return ".m.rule.tombstone"_ss;}
constexpr raii::static_string roomnotif(void){return ".m.rule.roomnotif"_ss;} constexpr rexy::static_string roomnotif(void){return ".m.rule.roomnotif"_ss;}
constexpr raii::static_string contains_username(void){return ".m.rule.contains_user_name"_ss;} constexpr rexy::static_string contains_username(void){return ".m.rule.contains_user_name"_ss;}
constexpr raii::static_string call(void){return ".m.rule.call"_ss;} constexpr rexy::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 rexy::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 rexy::static_string message(void){return ".m.rule.message"_ss;}
constexpr raii::static_string encrypted(void){return ".m.rule.encrypted"_ss;} constexpr rexy::static_string encrypted(void){return ".m.rule.encrypted"_ss;}
} }
namespace e2e{ namespace e2e{
constexpr raii::static_string curve_aes_sha2(void){return "m.olm.v1.curve25519-aes-sha2"_ss;} constexpr rexy::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 rexy::static_string aes_sha2(void){return "m.megolm.v1.aes-sha2"_ss;}
constexpr raii::static_string encryption(void){return "m.room.encryption"_ss;} constexpr rexy::static_string encryption(void){return "m.room.encryption"_ss;}
constexpr raii::static_string key(void){return "m.room_key"_ss;} constexpr rexy::static_string key(void){return "m.room_key"_ss;}
constexpr raii::static_string key_request(void){return "m.room_key_request"_ss;} constexpr rexy::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 rexy::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 dummy(void){return "m.dummy"_ss;}
} }
namespace room{ namespace room{
constexpr raii::static_string aliases(void){return "m.room.aliases"_ss;} constexpr rexy::static_string aliases(void){return "m.room.aliases"_ss;}
constexpr raii::static_string canonical_alias(void){return "m.room.canonical_alias"_ss;} constexpr rexy::static_string canonical_alias(void){return "m.room.canonical_alias"_ss;}
constexpr raii::static_string create(void){return "m.room.create"_ss;} constexpr rexy::static_string create(void){return "m.room.create"_ss;}
constexpr raii::static_string join_rules(void){return "m.room.join_rules"_ss;} constexpr rexy::static_string join_rules(void){return "m.room.join_rules"_ss;}
constexpr raii::static_string member(void){return "m.room.member"_ss;} constexpr rexy::static_string member(void){return "m.room.member"_ss;}
constexpr raii::static_string power_levels(void){return "m.room.power_levels"_ss;} constexpr rexy::static_string power_levels(void){return "m.room.power_levels"_ss;}
constexpr raii::static_string redaction(void){return "m.room.redaction"_ss;} constexpr rexy::static_string redaction(void){return "m.room.redaction"_ss;}
constexpr raii::static_string heroes(void){return "m.heroes"_ss;} constexpr rexy::static_string heroes(void){return "m.heroes"_ss;}
constexpr raii::static_string message(void){return "m.room.message"_ss;} constexpr rexy::static_string message(void){return "m.room.message"_ss;}
constexpr raii::static_string sticker(void){return "m.sticker"_ss;} constexpr rexy::static_string sticker(void){return "m.sticker"_ss;}
[[deprecated]] constexpr raii::static_string message_feedback(void){return "m.room.message.feedback"_ss;} [[deprecated]] constexpr rexy::static_string message_feedback(void){return "m.room.message.feedback"_ss;}
constexpr raii::static_string name(void){return "m.room.name"_ss;} constexpr rexy::static_string name(void){return "m.room.name"_ss;}
constexpr raii::static_string topic(void){return "m.room.topic"_ss;} constexpr rexy::static_string topic(void){return "m.room.topic"_ss;}
constexpr raii::static_string avatar(void){return "m.room.avatar"_ss;} constexpr rexy::static_string avatar(void){return "m.room.avatar"_ss;}
constexpr raii::static_string pinned_events(void){return "m.room.pinned_events"_ss;} constexpr rexy::static_string pinned_events(void){return "m.room.pinned_events"_ss;}
constexpr raii::static_string typing(void){return "m.typing"_ss;} constexpr rexy::static_string typing(void){return "m.typing"_ss;}
constexpr raii::static_string receipt(void){return "m.receipt"_ss;} constexpr rexy::static_string receipt(void){return "m.receipt"_ss;}
constexpr raii::static_string fully_read(void){return "m.fully_read"_ss;} constexpr rexy::static_string fully_read(void){return "m.fully_read"_ss;}
constexpr raii::static_string history_visibility(void){return "m.room.history_visibility"_ss;} constexpr rexy::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 rexy::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 rexy::static_string guest_access(void){return "m.room.guest_access"_ss;}
constexpr raii::static_string tag(void){return "m.tag"_ss;} constexpr rexy::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 server_acl(void){return "m.room.server_acl"_ss;}
} }
namespace msgtype{ namespace msgtype{
constexpr raii::static_string text(void){return "m.text"_ss;} constexpr rexy::static_string text(void){return "m.text"_ss;}
constexpr raii::static_string emote(void){return "m.emote"_ss;} constexpr rexy::static_string emote(void){return "m.emote"_ss;}
constexpr raii::static_string notice(void){return "m.notice"_ss;} constexpr rexy::static_string notice(void){return "m.notice"_ss;}
constexpr raii::static_string image(void){return "m.image"_ss;} constexpr rexy::static_string image(void){return "m.image"_ss;}
constexpr raii::static_string file(void){return "m.file"_ss;} constexpr rexy::static_string file(void){return "m.file"_ss;}
constexpr raii::static_string audio(void){return "m.audio"_ss;} constexpr rexy::static_string audio(void){return "m.audio"_ss;}
constexpr raii::static_string location(void){return "m.location"_ss;} constexpr rexy::static_string location(void){return "m.location"_ss;}
constexpr raii::static_string video(void){return "m.video"_ss;} constexpr rexy::static_string video(void){return "m.video"_ss;}
constexpr raii::static_string server_notice(void){return "m.server_notice"_ss;} constexpr rexy::static_string server_notice(void){return "m.server_notice"_ss;}
} }
namespace call{ namespace call{
constexpr raii::static_string invite(void){return "m.call.invite"_ss;} constexpr rexy::static_string invite(void){return "m.call.invite"_ss;}
constexpr raii::static_string candidates(void){return "m.call.candidates"_ss;} constexpr rexy::static_string candidates(void){return "m.call.candidates"_ss;}
constexpr raii::static_string answer(void){return "m.call.answer"_ss;} constexpr rexy::static_string answer(void){return "m.call.answer"_ss;}
constexpr raii::static_string hangup(void){return "m.call.hangup"_ss;} constexpr rexy::static_string hangup(void){return "m.call.hangup"_ss;}
} }
} }

34
include/matrix/rest/client_url_list.hpp
View File

@ -20,18 +20,18 @@
#define MATRIX_REST_CLIENT_URL_LIST_HPP #define MATRIX_REST_CLIENT_URL_LIST_HPP
#include "matrix/session_info.hpp" #include "matrix/session_info.hpp"
#include "raii/string.hpp" #include <rexy/string.hpp>
#include "matrix/rest/urls_common.hpp" #include "matrix/rest/urls_common.hpp"
namespace matrix::rest{ namespace matrix::rest{
class client_url_list class client_url_list
{ {
private: private:
raii::string m_create_room; rexy::string m_create_room;
raii::string m_file_upload; rexy::string m_file_upload;
raii::string m_room_list; rexy::string m_room_list;
raii::string m_alias_lookup; rexy::string m_alias_lookup;
raii::string m_profile_picture; rexy::string m_profile_picture;
public: public:
client_url_list(void) = default; 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=(const client_url_list&) = default;
client_url_list& operator=(client_url_list&&) = default; client_url_list& operator=(client_url_list&&) = default;
const raii::string& create_room(void)const; const rexy::string& create_room(void)const;
const raii::string& file_upload(void)const; const rexy::string& file_upload(void)const;
const raii::string& room_list(void)const; const rexy::string& room_list(void)const;
const raii::string& alias_lookup(void)const; const rexy::string& alias_lookup(void)const;
const raii::string& profile_picture(void)const; const rexy::string& profile_picture(void)const;
raii::string displayname(const session_info& session, const raii::string_base& userid)const; rexy::string displayname(const session_info& session, const rexy::string_base& userid)const;
raii::string file_download(const session_info& session, const raii::string_base& mediaid); rexy::string file_download(const session_info& session, const rexy::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; rexy::string file_thumbnail(const session_info& session, const rexy::string_base& fileurl, int width, int height, const rexy::string_base& method)const;
raii::string presence(const session_info& session, const raii::string_base& userid)const; rexy::string presence(const session_info& session, const rexy::string_base& userid)const;
raii::string sync(const session_info& session, const raii::rjp_string& batch, const raii::string& timeout); rexy::string sync(const session_info& session, const raii::rjp_string& batch, const rexy::string& timeout);
void repopulate(const session_info&); void repopulate(const session_info&);
void invalidate(void); void invalidate(void);
private: 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);
}; };
} }

54
include/matrix/rest/room_url_list.hpp
View File

@ -19,7 +19,7 @@
#ifndef MATRIX_ROOM_URL_LIST_HPP #ifndef MATRIX_ROOM_URL_LIST_HPP
#define MATRIX_ROOM_URL_LIST_HPP #define MATRIX_ROOM_URL_LIST_HPP
#include "raii/string.hpp" #include <rexy/string.hpp>
#include "matrix/session_info.hpp" #include "matrix/session_info.hpp"
namespace matrix{ namespace matrix{
@ -27,35 +27,35 @@ namespace matrix{
class room_url_list class room_url_list
{ {
private: private:
raii::string m_typing; rexy::string m_typing;
raii::string m_kick; rexy::string m_kick;
raii::string m_ban; rexy::string m_ban;
raii::string m_unban; rexy::string m_unban;
raii::string m_invite; rexy::string m_invite;
raii::string m_members; rexy::string m_members;
public: public:
room_url_list(const session_info& session, const raii::string_base& roomid); room_url_list(const session_info& session, const rexy::string_base& roomid);
raii::string join(const session_info& session, const raii::string_base& roomid)const; rexy::string join(const session_info& session, const rexy::string_base& roomid)const;
raii::string leave(const session_info& session, const raii::string_base& roomid)const; rexy::string leave(const session_info& session, const rexy::string_base& roomid)const;
raii::string forget(const session_info& session, const raii::string_base& roomid)const; rexy::string forget(const session_info& session, const rexy::string_base& roomid)const;
raii::string upgrade(const session_info& session, const raii::string_base& roomid)const; rexy::string upgrade(const session_info& session, const rexy::string_base& roomid)const;
raii::string read_receipt(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const; rexy::string read_receipt(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const;
raii::string send(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventtype)const; rexy::string send(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventtype)const;
raii::string redact(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const; rexy::string redact(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const;
raii::string event(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const; rexy::string event(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const;
const raii::string& typing(void)const; const rexy::string& typing(void)const;
const raii::string& kick(void)const; const rexy::string& kick(void)const;
const raii::string& ban(void)const; const rexy::string& ban(void)const;
const raii::string& unban(void)const; const rexy::string& unban(void)const;
const raii::string& invite(void)const; const rexy::string& invite(void)const;
const raii::string& room_members(void)const; const rexy::string& room_members(void)const;
raii::string messages(const session_info& session, const raii::string_base& roomid, rexy::string messages(const session_info& session, const rexy::string_base& roomid,
const raii::string_base& from, const raii::string_base& to, const rexy::string_base& from, const rexy::string_base& to,
const raii::string_base& dir, int limit)const; 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); void invalidate_accesstoken(void);
private: private:
static constexpr const char* s_proto = "https://"; static constexpr const char* s_proto = "https://";

10
include/matrix/rest/session_urls.hpp
View File

@ -21,13 +21,13 @@
#include "matrix/rest/urls_common.hpp" #include "matrix/rest/urls_common.hpp"
#include "matrix/session_info.hpp" #include "matrix/session_info.hpp"
#include "raii/string.hpp" #include <rexy/string.hpp>
namespace matrix::rest::session_urls{ namespace matrix::rest::session_urls{
raii::string login(const session_info&); rexy::string login(const session_info&);
raii::string logout(const session_info&); rexy::string logout(const session_info&);
raii::string password(const session_info&); rexy::string password(const session_info&);
raii::string whoami(const session_info&); rexy::string whoami(const session_info&);
} }
#endif #endif

6
include/matrix/rest/urls_common.hpp
View File

@ -19,13 +19,13 @@
#ifndef MATRIX_REST_URLS_COMMON_HPP #ifndef MATRIX_REST_URLS_COMMON_HPP
#define MATRIX_REST_URLS_COMMON_HPP #define MATRIX_REST_URLS_COMMON_HPP
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
namespace matrix::rest{ namespace matrix::rest{
constexpr raii::static_string proto(void){ constexpr rexy::static_string proto(void){
return "https://"_ss; return "https://"_ss;
} }
constexpr raii::static_string revision(void){ constexpr rexy::static_string revision(void){
return "r0"_ss; return "r0"_ss;
} }
} }

40
include/matrix/roomcxn.hpp
View File

@ -21,7 +21,7 @@
#include "matrix/connection.hpp" #include "matrix/connection.hpp"
#include "matrix/upload_info.hpp" #include "matrix/upload_info.hpp"
#include "raii/string.hpp" #include <rexy/string.hpp>
#include "raii/rjp_string.hpp" #include "raii/rjp_string.hpp"
#include "matrix/rest/room_url_list.hpp" #include "matrix/rest/room_url_list.hpp"
#include "matrix/iterable.hpp" #include "matrix/iterable.hpp"
@ -34,12 +34,12 @@ namespace matrix{
class roomcxn : public connection class roomcxn : public connection
{ {
private: private:
raii::string m_roomid; rexy::string m_roomid;
room_url_list m_urls; room_url_list m_urls;
public: public:
roomcxn(const std::shared_ptr<session_info>&, const raii::string_base& roomid); roomcxn(const std::shared_ptr<session_info>&, const rexy::string_base& roomid);
roomcxn(const std::shared_ptr<session_info>& ses, raii::string&& roomid); roomcxn(const std::shared_ptr<session_info>& ses, rexy::string&& roomid);
roomcxn(const roomcxn&) = default; roomcxn(const roomcxn&) = default;
roomcxn(roomcxn&&) = default; roomcxn(roomcxn&&) = default;
@ -59,42 +59,42 @@ namespace matrix{
netreturn<std::vector<raii::rjp_string>> members(void)const; netreturn<std::vector<raii::rjp_string>> members(void)const;
//member management //member management
netreturn<void> invite(const raii::string_base& userid); netreturn<void> invite(const rexy::string_base& userid);
[[deprecated("Use roomcxn::kick instead")]] [[deprecated("Use roomcxn::kick instead")]]
netreturn<void> uninvite(const raii::string_base& userid, const raii::string_base& reason = raii::string()); netreturn<void> uninvite(const rexy::string_base& userid, const rexy::string_base& reason = rexy::string());
netreturn<void> kick(const raii::string_base& userid, const raii::string_base& reason = raii::string()); netreturn<void> kick(const rexy::string_base& userid, const rexy::string_base& reason = rexy::string());
netreturn<void> ban(const raii::string_base& userid, const raii::string_base& reason = raii::string()); netreturn<void> ban(const rexy::string_base& userid, const rexy::string_base& reason = rexy::string());
netreturn<void> unban(const raii::string_base& userid); netreturn<void> unban(const rexy::string_base& userid);
//sending events //sending events
netreturn<raii::rjp_string> send_custom_event(const raii::string_base& event, const raii::string_base& eventtype)const; netreturn<raii::rjp_string> send_custom_event(const rexy::string_base& event, const rexy::string_base& eventtype)const;
netreturn<raii::rjp_string> send_message(const raii::string_base& text)const; netreturn<raii::rjp_string> send_message(const rexy::string_base& text)const;
netreturn<raii::rjp_string> send_notice(const raii::string_base& text)const; netreturn<raii::rjp_string> send_notice(const rexy::string_base& text)const;
netreturn<raii::rjp_string> send_file(const uploaded_file& file)const; netreturn<raii::rjp_string> send_file(const uploaded_file& file)const;
netreturn<raii::rjp_string> send_image(const uploaded_image& image)const; netreturn<raii::rjp_string> send_image(const uploaded_image& image)const;
netreturn<raii::rjp_string> send_video(const uploaded_video& video)const; netreturn<raii::rjp_string> send_video(const uploaded_video& video)const;
netreturn<raii::rjp_string> send_audio(const uploaded_audio& audio)const; netreturn<raii::rjp_string> send_audio(const uploaded_audio& audio)const;
netreturn<raii::rjp_string> forward_event(const sync::room_event&)const; netreturn<raii::rjp_string> forward_event(const sync::room_event&)const;
netreturn<void> send_typing(bool active, int timeout = 5000)const; netreturn<void> send_typing(bool active, int timeout = 5000)const;
netreturn<void> send_read_receipt(const raii::string_base& eventid)const; netreturn<void> send_read_receipt(const rexy::string_base& eventid)const;
netreturn<sync::roomcxn_message_event_list> get_event(const raii::string_base& eventid)const; netreturn<sync::roomcxn_message_event_list> get_event(const rexy::string_base& eventid)const;
netreturn<raii::rjp_string> redact_event(const raii::string_base& eventid, const raii::string_base& reason)const; netreturn<raii::rjp_string> redact_event(const rexy::string_base& eventid, const rexy::string_base& reason)const;
netreturn<raii::rjp_string> redact_event(const raii::string_base& eventid)const; netreturn<raii::rjp_string> redact_event(const rexy::string_base& eventid)const;
//recieve events //recieve events
netreturn<sync::roomcxn_message_event_list> get_events_forward(int amount); netreturn<sync::roomcxn_message_event_list> get_events_forward(int amount);
netreturn<sync::roomcxn_message_event_list> get_events_backward(int amount); netreturn<sync::roomcxn_message_event_list> get_events_backward(int amount);
netreturn<sync::roomcxn_message_event_list> get_events_forward(int amount, const raii::string_base& from, const raii::string_base& to); netreturn<sync::roomcxn_message_event_list> get_events_forward(int amount, const rexy::string_base& from, const rexy::string_base& to);
netreturn<sync::roomcxn_message_event_list> get_events_backward(int amount, const raii::string_base& from, const raii::string_base& to); netreturn<sync::roomcxn_message_event_list> get_events_backward(int amount, const rexy::string_base& from, const rexy::string_base& to);
//meta stuff //meta stuff
void regenerate_urls(void); void regenerate_urls(void);
netreturn<raii::rjp_string> upgrade(int version)const; netreturn<raii::rjp_string> upgrade(int version)const;
private: private:
netreturn<sync::roomcxn_message_event_list> _get_events(int amount, raii::static_string direction, const raii::string_base& from, const raii::string_base& to); netreturn<sync::roomcxn_message_event_list> _get_events(int amount, rexy::static_string direction, const rexy::string_base& from, const rexy::string_base& to);
netreturn<raii::rjp_string> _send_message(const raii::string_base& msg)const; netreturn<raii::rjp_string> _send_message(const rexy::string_base& msg)const;
}; };
} }

24
include/matrix/session.hpp
View File

@ -23,7 +23,7 @@
#include "matrix/session_info.hpp" #include "matrix/session_info.hpp"
#include "matrix/auth.hpp" #include "matrix/auth.hpp"
#include "raii/curler.hpp" #include "raii/curler.hpp"
#include "raii/string.hpp" #include <rexy/string.hpp>
#include "matrix/connection.hpp" #include "matrix/connection.hpp"
#include <utility> //pair #include <utility> //pair
@ -64,8 +64,8 @@ namespace matrix{
* NOT thread safe. * NOT thread safe.
* Set the useragent for the session and all spawned clients and syncers. * Set the useragent for the session and all spawned clients and syncers.
*/ */
void set_useragent(const raii::string_base&); void set_useragent(const rexy::string_base&);
void set_useragent(raii::string&&); void set_useragent(rexy::string&&);
/* /*
@ -73,15 +73,15 @@ namespace matrix{
* Set the access token for the session and all spawned clients and syncers. * 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. * 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(const rexy::string_base&);
void set_access_token(raii::string&&); void set_access_token(rexy::string&&);
/* /*
* NOT thread safe. * NOT thread safe.
* Set the homeserver for the session and all spawned clients and syncers. * 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. * 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(const rexy::string_base&);
void set_homeserver(raii::string&&); void set_homeserver(rexy::string&&);
/* /*
* NOT thread safe. * NOT thread safe.
@ -97,7 +97,7 @@ namespace matrix{
* homeserver are valid. * homeserver are valid.
* Returns: true if success, false otherwise. * Returns: true if success, false otherwise.
*/ */
netreturn<void> login(const raii::string_base& username, const raii::string_base& pass); netreturn<void> 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. * 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; bool valid(void)const;
netreturn<void> change_password(const raii::string_base& oldpass, const raii::string_base& newpass); netreturn<void> change_password(const rexy::string_base& oldpass, const rexy::string_base& newpass);
/* /*
* Create a matrix::client which shares login details with this session. * 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 * Note the client and session will share memory for generated urls, homeserver, access_token, and
@ -127,11 +127,11 @@ namespace matrix{
*/ */
void invalidate(void); void invalidate(void);
private: private:
netreturn<void> _do_login(const raii::string_base& username, const raii::string_base& pass); netreturn<void> _do_login(const rexy::string_base& username, const rexy::string_base& pass);
void _populate_session_info(const auth_data& a); void _populate_session_info(const auth_data& a);
netreturn<raii::rjp_string> _get_userid(void); netreturn<raii::rjp_string> _get_userid(void);
raii::string _request_access_token(const raii::string_base& name, const raii::string_base& pass, const raii::string_base& loginurl)const; rexy::string _request_access_token(const rexy::string_base& name, const rexy::string_base& pass, const rexy::string_base& loginurl)const;
netreturn<std::pair<raii::rjp_string,raii::rjp_string>> _get_new_access_token(const raii::string_base& name, const raii::string_base& pass, const raii::string_base& loginurl); netreturn<std::pair<raii::rjp_string,raii::rjp_string>> _get_new_access_token(const rexy::string_base& name, const rexy::string_base& pass, const rexy::string_base& loginurl);
}; };
} }

8
include/matrix/session_info.hpp
View File

@ -19,15 +19,15 @@
#ifndef MATRIX_SESSION_INFO_HPP #ifndef MATRIX_SESSION_INFO_HPP
#define MATRIX_SESSION_INFO_HPP #define MATRIX_SESSION_INFO_HPP
#include "raii/string.hpp" #include <rexy/string.hpp>
#include "raii/rjp_string.hpp" #include "raii/rjp_string.hpp"
namespace matrix{ namespace matrix{
struct session_info{ struct session_info{
raii::string useragent; //useragent to identify our application rexy::string useragent; //useragent to identify our application
raii::string homeserver; //name of our homeserver rexy::string homeserver; //name of our homeserver
raii::rjp_string access_token; //authentication raii::rjp_string access_token; //authentication
raii::string auth_header; rexy::string auth_header;
raii::rjp_string userid; //userid including homeserver raii::rjp_string userid; //userid including homeserver
}; };
} }

8
include/matrix/sync_response.hpp
View File

@ -19,7 +19,7 @@
#ifndef SYNC_RESPONSE_HPP #ifndef SYNC_RESPONSE_HPP
#define SYNC_RESPONSE_HPP #define SYNC_RESPONSE_HPP
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
#include "raii/rjp_string.hpp" #include "raii/rjp_string.hpp"
#include "raii/rjp_iterator.hpp" #include "raii/rjp_iterator.hpp"
#include "raii/rjp_ptr.hpp" #include "raii/rjp_ptr.hpp"
@ -38,7 +38,7 @@ namespace matrix::sync{
RJP_value* m_room; RJP_value* m_room;
public: public:
constexpr room_event_response(RJP_value* room):m_room(room){} 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_event_list account_events(void);
room_ephem_event_list ephemeral_events(void); room_ephem_event_list ephemeral_events(void);
room_state_event_list state_events(void); room_state_event_list state_events(void);
@ -129,7 +129,7 @@ namespace matrix::sync{
raii::rjp_ptr m_root = nullptr; raii::rjp_ptr m_root = nullptr;
public: public:
constexpr client_response(void) = default; constexpr client_response(void) = default;
client_response(const raii::string_base& src); client_response(const rexy::string_base& src);
client_response(RJP_value* root); client_response(RJP_value* root);
room_list room_join_events(void)const; room_list room_join_events(void)const;
@ -137,7 +137,7 @@ namespace matrix::sync{
room_list room_leave_events(void)const; room_list room_leave_events(void)const;
device_list device_lists(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)&&; raii::rjp_string next_batch(void)&&;
event_list to_device_events(void)const; event_list to_device_events(void)const;

24
include/matrix/upload_info.hpp
View File

@ -20,8 +20,8 @@
#define MATRIX_UPLOAD_INFO_HPP #define MATRIX_UPLOAD_INFO_HPP
#include "raii/rjp_string.hpp" #include "raii/rjp_string.hpp"
#include "raii/string.hpp" #include <rexy/string.hpp>
#include "raii/binary.hpp" #include <rexy/binary.hpp>
#include <cstdlib> //size_t #include <cstdlib> //size_t
namespace matrix{ namespace matrix{
@ -29,16 +29,16 @@ namespace matrix{
class client; class client;
struct file_details{ struct file_details{
raii::binary data; rexy::binary data;
raii::string name; rexy::string name;
}; };
struct image_details : public file_details{ struct image_details : public file_details{
int width, height; int width, height;
raii::string mimetype; rexy::string mimetype;
}; };
struct video_details : public image_details{}; struct video_details : public image_details{};
struct audio_details : public file_details{ struct audio_details : public file_details{
raii::string mimetype; rexy::string mimetype;
}; };
class uploaded_file class uploaded_file
@ -46,8 +46,8 @@ namespace matrix{
friend class matrix::client; friend class matrix::client;
protected: protected:
raii::rjp_string m_fileurl = {}; raii::rjp_string m_fileurl = {};
raii::string m_filename = {}; rexy::string m_filename = {};
raii::string m_mimetype = {}; rexy::string m_mimetype = {};
size_t m_filesize = 0; size_t m_filesize = 0;
public: public:
@ -61,8 +61,8 @@ namespace matrix{
constexpr operator bool(void)const{return m_fileurl;} constexpr operator bool(void)const{return m_fileurl;}
const raii::string& mimetype(void)const{return m_mimetype;} const rexy::string& mimetype(void)const{return m_mimetype;}
const raii::string& name(void)const{return m_filename;} const rexy::string& name(void)const{return m_filename;}
const raii::rjp_string& url(void)const{return m_fileurl;} const raii::rjp_string& url(void)const{return m_fileurl;}
constexpr size_t size(void)const{return m_filesize;} constexpr size_t size(void)const{return m_filesize;}
}; };
@ -72,7 +72,7 @@ namespace matrix{
friend class matrix::client; friend class matrix::client;
protected: protected:
raii::rjp_string m_url; raii::rjp_string m_url;
raii::string m_mimetype; rexy::string m_mimetype;
size_t m_width = 0; size_t m_width = 0;
size_t m_height = 0; size_t m_height = 0;
size_t m_size = 0; size_t m_size = 0;
@ -92,7 +92,7 @@ namespace matrix{
constexpr size_t height(void)const{return m_height;} constexpr size_t height(void)const{return m_height;}
constexpr size_t size(void)const{return m_size;} constexpr size_t size(void)const{return m_size;}
const raii::rjp_string& url(void)const{return m_url;} 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 class uploaded_image : public uploaded_file
{ {

172
include/raii/binary.hpp
View File

@ -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 <http://www.gnu.org/licenses/>.
*/
#ifndef RAII_BINARY_HPP
#define RAII_BINARY_HPP
#include <cstdlib> //size_t
#include <utility> //move
#include <cstring> //memcpy
#include <algorithm> //max
#include <type_traits>
#include <new>
#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<class Allocator>
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 Allocator = detail::default_allocator<>>
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<char*>(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<char*>(Allocator::copy(data, size)), cap, size){}
binary_data(size_t size):
binary_base(reinterpret_cast<char*>(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<class T>
struct is_binary_type{
constexpr static bool value = std::is_same<decltype(is_binary_type_helper(std::declval<typename std::decay<T>::type>())),std::true_type>::value;
};
}
}
template<class Left, class Right, typename std::enable_if<raii::detail::is_binary_type<Left>::value && raii::detail::is_binary_type<Right>::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<class Left, class Right, typename std::enable_if<raii::detail::is_binary_type<Left>::value && raii::detail::is_binary_type<Right>::value,void>::type* = nullptr>
bool operator!=(Left&& l, Right&& r){
return !(std::forward<Left>(l) == std::forward<Right>(r));
}
template<class All, class Alr>
auto operator+(const raii::binary_data<All>& l, const raii::binary_data<Alr>& r){
raii::binary_data<All> retval(l.size() + r.size());
memcpy(retval.get(), l.get(), l.size());
memcpy(retval.get()+l.size(), r.get(), r.size());
return retval;
}
template<class All, class Alr>
decltype(auto) operator+=(raii::binary_data<All>& l, const raii::binary_data<Alr>& 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

71
include/raii/binary_string_conv.hpp
View File

@ -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 <http://www.gnu.org/licenses/>.
*/
#ifndef RAII_BINARY_STRING_CONV_HPP
#define RAII_BINARY_STRING_CONV_HPP
#include "raii/string.hpp"
#include "raii/binary.hpp"
namespace raii{
template<class Al, class Str = raii::string, typename std::enable_if<raii::detail::is_concrete_string<Str>::value,void>::type* = nullptr>
auto binary_to_string(const binary_data<Al>& b){
Str s(b.size()+1);
memcpy(s.get(), b.get(), b.size());
s[b.size()] = 0;
return s;
}
template<class Al, class Str = raii::string, typename std::enable_if<raii::detail::is_concrete_string<Str>::value && std::is_same<typename std::decay<Al>::type,typename Str::allocator_type>::value,void>::type* = nullptr>
auto binary_to_string(binary_data<Al>&& b){
Str s;
s.reset(b.get(), b.size());
b.release();
return s;
}
template<class Bin = raii::binary, typename std::enable_if<raii::detail::is_binary_type<Bin>::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<class Al, class Bin = raii::binary, typename std::enable_if<raii::detail::is_binary_type<Bin>::value && std::is_same<typename std::decay<Al>::type,typename Bin::allocator_type>::value,void>::type* = nullptr>
auto string_to_binary(string_intermediary<Al>&& s){
Bin b;
b.reset(s.get(), s.length()+1);
s.release();
return b;
}
}
template<class L, class R, typename std::enable_if<raii::detail::is_binary_type<L>::value && raii::detail::is_concrete_string<R>::value,void>::type* = nullptr>
decltype(auto) operator+=(L& l, R&& r){
l.append(r.get(), r.length()+1);
return l;
}
template<class L, class R, typename std::enable_if<raii::detail::is_binary_type<L>::value && raii::detail::is_string<R>::value && !raii::detail::is_concrete_string<R>::value,void>::type* = nullptr>
decltype(auto) operator+=(L& l, R&& r){
raii::string concrete = r;
return (l = concrete);
}
template<class L, class R, typename std::enable_if<raii::detail::is_concrete_string<L>::value && raii::detail::is_binary_type<R>::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

4
include/raii/curl_string.hpp
View File

@ -19,7 +19,7 @@
#ifndef RAII_CURL_STRING_HPP #ifndef RAII_CURL_STRING_HPP
#define RAII_CURL_STRING_HPP #define RAII_CURL_STRING_HPP
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
#include <curl/curl.h> #include <curl/curl.h>
#include <cstddef> //size_t #include <cstddef> //size_t
@ -41,7 +41,7 @@ namespace raii{
} }
using curl_string = string_intermediary<detail::curl_allocator>; using curl_string = rexy::string_intermediary<detail::curl_allocator>;
} }

8
include/raii/curler.hpp
View File

@ -54,13 +54,13 @@ namespace raii{
curler& getreq(void); curler& getreq(void);
curler& setheader(const curl_llist& h); curler& setheader(const curl_llist& h);
curler& seturl(const char* s); 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 char* s);
curler& setuseragent(const string_base& s); curler& setuseragent(const rexy::string_base& s);
curler& setuserpwd(const char* 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 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& forcessl(long version = CURL_SSLVERSION_DEFAULT);
curler& setwritefun(write_function); curler& setwritefun(write_function);
curler& setwritedata(void*); curler& setwritedata(void*);

48
include/raii/default_allocator.hpp
View File

@ -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 <http://www.gnu.org/licenses/>.
*/
#ifndef RAII_DEFAULT_ALLOCATOR_HPP
#define RAII_DEFAULT_ALLOCATOR_HPP
#include <cstdlib> //size_t
#include <cstring> //memcpy
#include <new>
namespace raii{
namespace detail{
template<size_t Alignment = __STDCPP_DEFAULT_NEW_ALIGNMENT__>
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<char*>(allocate(size));
memcpy(tmp, c, size);
return tmp;
}
};
}
}
#endif

68
include/raii/filerd.hpp
View File

@ -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 <http://www.gnu.org/licenses/>.
*/
#ifndef RAII_FILERD_HPP
#define RAII_FILERD_HPP
#include <cstdio> //FILE
#include <cstddef> //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

2
include/raii/rjp_iterator.hpp
View File

@ -43,7 +43,7 @@ namespace raii{
m_root(std::exchange(e.m_root, nullptr)), m_root(std::exchange(e.m_root, nullptr)),
m_obj(e.m_obj) m_obj(e.m_obj)
{ {
e.m_obj = RJP_object_iterator{0}; e.m_obj = {};
} }
rjp_object_iterator& operator=(rjp_object_iterator&& e){ rjp_object_iterator& operator=(rjp_object_iterator&& e){
std::swap(m_root, e.m_root); std::swap(m_root, e.m_root);

10
include/raii/rjp_string.hpp
View File

@ -20,7 +20,7 @@
#define RAII_RJP_STRING_HPP #define RAII_RJP_STRING_HPP
#include <rjp.h> #include <rjp.h>
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
#include <utility> //exchange #include <utility> //exchange
#include <cstdlib> //memcpy #include <cstdlib> //memcpy
@ -39,16 +39,16 @@ namespace raii{
} }
//rjp allocated string //rjp allocated string
struct rjp_string : public string_intermediary<detail::rjp_allocator> struct rjp_string : public rexy::string_intermediary<detail::rjp_allocator>
{ {
rjp_string(const rjp_string&) = default; rjp_string(const rjp_string&) = default;
rjp_string(rjp_string&&) = default; rjp_string(rjp_string&&) = default;
rjp_string& operator=(const rjp_string&) = default; rjp_string& operator=(const rjp_string&) = default;
rjp_string& operator=(rjp_string&&) = default; rjp_string& operator=(rjp_string&&) = default;
using string_intermediary<detail::rjp_allocator>::string_intermediary; using rexy::string_intermediary<detail::rjp_allocator>::string_intermediary;
rjp_string(RJP_value* r): rjp_string(RJP_value* r):
string_intermediary<detail::rjp_allocator>(r ? rjp_get_string(r)->value : nullptr, rexy::string_intermediary<detail::rjp_allocator>(r ? rjp_get_string(r)->value : nullptr,
r ? rjp_get_string(r)->length : 0, r ? rjp_get_string(r)->length : 0,
r ? rjp_get_string(r)->length : 0) r ? rjp_get_string(r)->length : 0)
{ {
@ -59,7 +59,7 @@ namespace raii{
rjp_set_null(r); rjp_set_null(r);
} }
} }
using string_intermediary<detail::rjp_allocator>::operator=; using rexy::string_intermediary<detail::rjp_allocator>::operator=;
rjp_string& operator=(RJP_value* r){ rjp_string& operator=(RJP_value* r){
if(!r) if(!r)
return *this; return *this;

32
include/raii/string.hpp
View File

@ -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 <http://www.gnu.org/licenses/>.
*/
#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<detail::default_allocator<>>;
}
#endif

294
include/raii/string_base.hpp
View File

@ -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 <http://www.gnu.org/licenses/>.
*/
#ifndef RAII_STRING_BASE_HPP
#define RAII_STRING_BASE_HPP
#include <type_traits> //is_same, integral_contant, enable_if, etc
#include <utility> //forward
#include <cstdlib> //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 Allocator>
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 Left, class Right>
class string_cat_expr : public string_expr
{
private:
Left m_l;
Right m_r;
public:
template<class T, class U>
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<class Alloc>
operator string_intermediary<Alloc>(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<size_t N>
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<class T>
struct is_string{
static constexpr bool value = std::is_same<std::true_type,decltype(is_string_helper(std::declval<T>()))>::value;
};
std::true_type is_string_base(string_base*);
std::false_type is_string_base(...);
template<class T>
struct is_concrete_string{
static constexpr bool value = std::is_same<std::true_type,decltype(is_string_base(std::declval<typename std::decay<T>::type*>()))>::value;
};
template<class... Args>
std::true_type is_tuple_helper(std::tuple<Args...>);
std::false_type is_tuple_helper(...);
template<class T>
struct is_tuple{
static constexpr bool value = std::is_same<std::true_type,decltype(is_tuple_helper(std::declval<T>()))>::value;
};
//check for member function 'length'
template<class T>
struct has_len{
template<class U, class V>
struct check;
template<class U>
static std::true_type test(check<U,decltype(&U::length)>*);
template<class U>
static std::false_type test(...);
static constexpr bool value = std::is_same<std::true_type,decltype(test<T>(0))>::value;
};
template<class Targ>
struct appender
{
private:
Targ& m_targ;
public:
appender(Targ& t);
template<class L, class R>
void operator()(const string_cat_expr<L,R>& 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<class Str1, class Str2, typename std::enable_if<raii::detail::is_concrete_string<Str1>::value&&raii::detail::is_concrete_string<Str2>::value,void>::type* = nullptr>
bool operator==(Str1&& left, Str2&& right){
return left && right && left.length() == right.length() && !strcmp(left.get(), right.get());
}
template<class Str1, class Str2, typename std::enable_if<raii::detail::is_concrete_string<Str1>::value&&raii::detail::is_concrete_string<Str2>::value,void>::type* = nullptr>
bool operator!=(Str1&& left, Str2&& right){
return !(left == right);
}
template<class Right, typename std::enable_if<raii::detail::is_string<Right>::value && std::is_rvalue_reference<Right&&>::value,void>::type* = nullptr>
constexpr auto operator+(const char* left, Right&& right){
return raii::string_cat_expr<raii::static_string,typename std::remove_reference<Right>::type>(raii::static_string(left), std::move(right));
}
template<class Right, typename std::enable_if<raii::detail::is_string<Right>::value && !std::is_rvalue_reference<Right&&>::value,void>::type* = nullptr>
constexpr auto operator+(const char* left, Right&& right){
return raii::string_cat_expr<raii::static_string,decltype(std::forward<Right>(right))>(raii::static_string(left), std::forward<Right>(right));
}
template<class Left, typename std::enable_if<raii::detail::is_string<Left>::value && std::is_rvalue_reference<Left&&>::value,void>::type* = nullptr>
constexpr auto operator+(Left&& left, const char* right){
return raii::string_cat_expr<typename std::remove_reference<Left>::type,raii::static_string>(std::move(left), raii::static_string(right));
}
template<class Left, typename std::enable_if<raii::detail::is_string<Left>::value && !std::is_rvalue_reference<Left&&>::value,void>::type* = nullptr>
constexpr auto operator+(Left&& left, const char* right){
return raii::string_cat_expr<decltype(std::forward<Left>(left)),raii::static_string>(std::forward<Left>(left), raii::static_string(right));
}
template<class Left,
class Right,
typename std::enable_if<
raii::detail::is_string<Left>::value &&
raii::detail::is_string<Right>::value &&
std::is_rvalue_reference<Left&&>::value &&
std::is_rvalue_reference<Right&&>::value,
void>::type* = nullptr>
constexpr auto operator+(Left&& l, Right&& r){
return raii::string_cat_expr<typename std::remove_reference<Left>::type,typename std::remove_reference<Right>::type>(std::move(l), std::move(r));
}
template<class Left,
class Right,
typename std::enable_if<
raii::detail::is_string<Left>::value &&
raii::detail::is_string<Right>::value &&
!std::is_rvalue_reference<Left&&>::value &&
!std::is_rvalue_reference<Right&&>::value,
void>::type* = nullptr>
constexpr auto operator+(Left&& l, Right&& r){
return raii::string_cat_expr<decltype(std::forward<Left>(l)),decltype(std::forward<Right>(r))>(std::forward<Left>(l), std::forward<Right>(r));
}
template<class Left,
class Right,
typename std::enable_if<
raii::detail::is_string<Left>::value &&
raii::detail::is_string<Right>::value &&
std::is_rvalue_reference<Left&&>::value &&
!std::is_rvalue_reference<Right&&>::value,
void>::type* = nullptr>
constexpr auto operator+(Left&& l, Right&& r){
return raii::string_cat_expr<typename std::remove_reference<Left>::type,decltype(std::forward<Right>(r))>(std::move(l), std::forward<Right>(r));
}
template<class Left,
class Right,
typename std::enable_if<
raii::detail::is_string<Left>::value &&
raii::detail::is_string<Right>::value &&
!std::is_rvalue_reference<Left&&>::value &&
std::is_rvalue_reference<Right&&>::value,
void>::type* = nullptr>
constexpr auto operator+(Left&& l, Right&& r){
return raii::string_cat_expr<decltype(std::forward<Left>(l)),typename std::remove_reference<Right>::type>(std::forward<Left>(l), std::move(r));
}
template<class Left, class Right, typename std::enable_if<raii::detail::is_string<Left>::value&&raii::detail::is_string<Right>::value,void>::type* = nullptr>
decltype(auto) operator+=(Left& l, Right&& r){
return l = (l + std::forward<Right>(r));
}
template<class Left, typename std::enable_if<raii::detail::is_string<Left>::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

247
include/raii/string_base.tpp
View File

@ -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 <http://www.gnu.org/licenses/>.
*/
#ifndef RAII_STRING_BASE_TPP
#define RAII_STRING_BASE_TPP
#include <utility> //forward, move, swap, etc
#include <cstdlib> //memcpy
#include <cstring> //strlen, strcpy
#include <algorithm> //max
namespace raii{
template<class Allocator>
string_intermediary<Allocator>::string_intermediary(char* data, size_t len):
string_base(data, len){}
template<class Allocator>
string_intermediary<Allocator>::string_intermediary(char* data, size_t len, size_t cap):
string_base(data, len, cap){}
template<class Allocator>
string_intermediary<Allocator>::string_intermediary(const char* data, size_t len):
string_base(reinterpret_cast<char*>(len ? Allocator::copy(data, len+1) : nullptr), len)
{
m_data[len] = 0;
}
template<class Allocator>
string_intermediary<Allocator>::string_intermediary(const char* data):
string_base(data ? strlen(data) : 0)
{
if(m_cap){
m_data = reinterpret_cast<char*>(Allocator::copy(data, m_cap+1));
m_length = m_cap;
}
}
template<class Allocator>
string_intermediary<Allocator>::string_intermediary(size_t len):
string_base(reinterpret_cast<char*>(len ? Allocator::allocate(len+1) : nullptr), len)
{
m_data[len] = 0;
}
template<class Allocator>
string_intermediary<Allocator>::string_intermediary(size_t len, size_t cap):
string_base(reinterpret_cast<char*>(len ? Allocator::allocate(len+1) : nullptr), len, cap)
{
m_data[len] = 0;
}
//normal copy and move ctors
template<class Allocator>
string_intermediary<Allocator>::string_intermediary(const string_intermediary& b):
string_base(reinterpret_cast<char*>(b.m_length ? Allocator::copy(b.m_data, b.m_length+1) : nullptr), b.m_length, b.m_cap){}
template<class Allocator>
string_intermediary<Allocator>::string_intermediary(string_intermediary&& s):
string_base(std::exchange(s.m_data, nullptr), s.m_length, s.m_cap){}
template<class Allocator>
string_intermediary<Allocator>::string_intermediary(const string_base& b):
string_base(reinterpret_cast<char*>(b.length() ? Allocator::copy(b.get(), b.length()+1) : nullptr), b.length(), b.capacity()){}
//dtor
template<class Allocator>
string_intermediary<Allocator>::~string_intermediary(void){
Allocator::free(m_data);
}
template<class Allocator>
string_intermediary<Allocator>& string_intermediary<Allocator>::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<class Allocator>
string_intermediary<Allocator>& string_intermediary<Allocator>::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<class Allocator>
string_intermediary<Allocator>& string_intermediary<Allocator>::operator=(const char* c){
return _copy_string(c, strlen(c));
}
//Copy from other string_base
template<class Allocator>
string_intermediary<Allocator>& string_intermediary<Allocator>::operator=(const string_base& s){
return _copy_string(s.get(), s.length());
}
//Replace managed pointer. Frees existing value
template<class Allocator>
void string_intermediary<Allocator>::reset(char* val){
Allocator::free(m_data);
m_data = val;
m_length = val ? strlen(val) : 0;
m_cap = m_length;
}
template<class Allocator>
void string_intermediary<Allocator>::reset(char* val, size_t len){
Allocator::free(m_data);
m_data = val;
m_length = len;
m_cap = len;
}
template<class Allocator>
bool string_intermediary<Allocator>::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<class Allocator>
void string_intermediary<Allocator>::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<class Allocator>
void string_intermediary<Allocator>::append(const char* data){
if(data)
append(data, strlen(data));
}
template<class Allocator>
void string_intermediary<Allocator>::append(const string_base& s){
append(s.get(), s.length());
}
template<class Allocator>
string_intermediary<Allocator>& string_intermediary<Allocator>::_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<char*>(Allocator::copy(s, m_cap+1));
if(!m_data){
m_length = 0;
m_cap = 0;
return *this;
}
}
m_length = len;
return *this;
}
template<class Left, class Right>
template<class T, class U>
constexpr string_cat_expr<Left,Right>::string_cat_expr(T&& l, U&& r):
m_l(std::forward<T>(l)),
m_r(std::forward<U>(r)){}
template<class Left, class Right>
constexpr string_cat_expr<Left,Right>::string_cat_expr(const string_cat_expr& s):
m_l(std::forward<Left>(s.m_l)),
m_r(std::forward<Right>(s.m_r)){}
template<class Left, class Right>
constexpr string_cat_expr<Left,Right>::string_cat_expr(string_cat_expr&& s):
m_l(std::forward<Left>(s.m_l)),
m_r(std::forward<Right>(s.m_r)){}
template<class Left, class Right>
constexpr size_t string_cat_expr<Left,Right>::length(void)const{
return m_l.length() + m_r.length();
}
template<class Left, class Right>
template<class Alloc>
string_cat_expr<Left,Right>::operator string_intermediary<Alloc>(void){
size_t len = length();
string_intermediary<Alloc> ret(len);
detail::appender<string_intermediary<Alloc>> append(ret);
append(*this);
return ret;
}
template<class Left, class Right>
constexpr const Left& string_cat_expr<Left,Right>::left(void)const{
return m_l;
}
template<class Left, class Right>
constexpr const Right& string_cat_expr<Left,Right>::right(void)const{
return m_r;
}
template<size_t N>
constexpr static_string::static_string(const char(&str)[N]):
string_base(const_cast<char*>(str), N, N){}
constexpr static_string::static_string(const char* str, size_t len):
string_base(const_cast<char*>(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<class Targ>
appender<Targ>::appender(Targ& t): m_targ(t){}
template<class Targ>
template<class L, class R>
void appender<Targ>::operator()(const string_cat_expr<L,R>& str){
(*this)(str.left());
(*this)(str.right());
}
template<class Targ>
void appender<Targ>::operator()(const string_base& str){
m_targ.append(str.get(), str.length());
}
}
} //namespace raii
#endif

14
include/raii/util.hpp
View File

@ -19,7 +19,7 @@
#ifndef RAII_UTIL_HPP #ifndef RAII_UTIL_HPP
#define RAII_UTIL_HPP #define RAII_UTIL_HPP
#include "raii/string.hpp" #include <rexy/string.hpp>
namespace raii{ namespace raii{
@ -44,20 +44,20 @@ namespace raii{
return len; return len;
} }
} }
template<class T, typename std::enable_if<detail::is_string<T>::value && !detail::is_concrete_string<T>::value,void>::type* = nullptr> template<class T, typename std::enable_if<rexy::detail::is_string<T>::value && !rexy::detail::is_concrete_string<T>::value,void>::type* = nullptr>
string json_escape(T&& t){ rexy::string json_escape(T&& t){
auto tup = t.get(); auto tup = t.get();
size_t len = detail::_calc_escaped_len_all(tup); size_t len = detail::_calc_escaped_len_all(tup);
char* tmp = reinterpret_cast<char*>(string::allocator_type::allocate(len+1)); char* tmp = reinterpret_cast<char*>(rexy::string::allocator_type::allocate(len+1));
detail::_js_assign(tmp, tup, 0); detail::_js_assign(tmp, tup, 0);
tmp[len] = 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); size_t intlen(int i);
raii::string itostr(int i); rexy::string itostr(int i);
} }
#endif #endif

2
makefile
View File

@ -32,7 +32,7 @@ RELEASE?=0
ifneq ($(WINDOWS),1) ifneq ($(WINDOWS),1)
CXX::=g++ CXX::=g++
LDLIBS::=-lcurl -lrjp LDLIBS::=-lcurl -lrjp -lrexy
LDFLAGS::= LDFLAGS::=
STRIP::=strip STRIP::=strip
RANLIB::=ranlib RANLIB::=ranlib

52
src/matrix/client.cpp
View File

@ -19,8 +19,8 @@
#include "matrix/client.hpp" #include "matrix/client.hpp"
#include "matrix/fat_strings.hpp" #include "matrix/fat_strings.hpp"
#include "matrix/json_targets.hpp" #include "matrix/json_targets.hpp"
#include "raii/filerd.hpp" #include <rexy/filerd.hpp>
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
#include "raii/rjp_ptr.hpp" #include "raii/rjp_ptr.hpp"
#include "raii/util.hpp" #include "raii/util.hpp"
@ -32,19 +32,19 @@ namespace matrix{
m_urls(std::make_shared<matrix::rest::client_url_list>(*ses)){} m_urls(std::make_shared<matrix::rest::client_url_list>(*ses)){}
//networked setter //networked setter
netreturn<void> client::set_display_name(const raii::string_base& newname){ netreturn<void> 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()); _put_curl(json::_displayname_set(newname), m_urls->displayname(*m_ses, m_ses->userid), raii::curl_llist());
return netreturn<void>(raii::string(), raii::string(), http_status()); return netreturn<void>(rexy::string(), rexy::string(), http_status());
} }
netreturn<void> client::set_profile_picture(const raii::string_base& media_url){ netreturn<void> client::set_profile_picture(const rexy::string_base& media_url){
_put_curl(json::_avatar_set(media_url), m_urls->profile_picture(), raii::curl_llist()); _put_curl(json::_avatar_set(media_url), m_urls->profile_picture(), raii::curl_llist());
return netreturn<void>(raii::string(), raii::string(), http_status()); return netreturn<void>(rexy::string(), rexy::string(), http_status());
} }
netreturn<void> client::set_presence(const raii::string_base& status){ netreturn<void> 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()); _put_curl(json::_presence_set(status), m_urls->presence(*m_ses, m_ses->userid), raii::curl_llist());
return netreturn<void>(raii::string(), raii::string(), http_status()); return netreturn<void>(rexy::string(), rexy::string(), http_status());
} }
netreturn<raii::rjp_string> client::get_presence(const raii::string_base& userid){ netreturn<raii::rjp_string> client::get_presence(const rexy::string_base& userid){
return _get_and_find(m_urls->presence(*m_ses, userid), json::keys::presence()); return _get_and_find(m_urls->presence(*m_ses, userid), json::keys::presence());
} }
@ -52,18 +52,18 @@ namespace matrix{
netreturn<raii::rjp_string> client::get_display_name(void)const{ netreturn<raii::rjp_string> client::get_display_name(void)const{
return _get_and_find(m_urls->displayname(*m_ses, m_ses->userid), json::keys::displayname()); return _get_and_find(m_urls->displayname(*m_ses, m_ses->userid), json::keys::displayname());
} }
netreturn<raii::rjp_string> client::get_display_name(const raii::string_base& userid)const{ netreturn<raii::rjp_string> client::get_display_name(const rexy::string_base& userid)const{
return _get_and_find(m_urls->displayname(*m_ses, userid), json::keys::displayname()); return _get_and_find(m_urls->displayname(*m_ses, userid), json::keys::displayname());
} }
netreturn<raii::rjp_string> client::get_profile_picture(void)const{ netreturn<raii::rjp_string> client::get_profile_picture(void)const{
return _get_and_find(m_urls->profile_picture(), json::keys::avatarurl()); return _get_and_find(m_urls->profile_picture(), json::keys::avatarurl());
} }
netreturn<raii::rjp_string> client::room_alias_to_id(const raii::string_base& alias)const{ netreturn<raii::rjp_string> client::room_alias_to_id(const rexy::string_base& alias)const{
auto tmp = m_curl.encode(alias, alias.length()); 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<std::vector<raii::rjp_string>> client::list_rooms(void)const{ netreturn<std::vector<raii::rjp_string>> 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) if(!reply)
return _create_netreturn(reply, http_status()); return _create_netreturn(reply, http_status());
@ -86,13 +86,13 @@ namespace matrix{
} }
//room membership //room membership
netreturn<raii::rjp_string> client::create_room(const raii::string_base& name, const raii::string_base& alias)const{ netreturn<raii::rjp_string> 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()); 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); 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)); return roomcxn(m_ses, std::move(roomid));
} }
@ -101,7 +101,7 @@ namespace matrix{
return _upload_file(file, raii::curl_llist{}); return _upload_file(file, raii::curl_llist{});
} }
netreturn<uploaded_image> client::upload_image(const image_details& file)const{ netreturn<uploaded_image> 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<uploaded_file> upfile = _upload_file(file, headers); netreturn<uploaded_file> upfile = _upload_file(file, headers);
netreturn<uploaded_image> retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus()); netreturn<uploaded_image> retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus());
retval.value().m_width = file.width; retval.value().m_width = file.width;
@ -110,14 +110,14 @@ namespace matrix{
return retval; return retval;
} }
netreturn<uploaded_audio> client::upload_audio(const audio_details& file)const{ netreturn<uploaded_audio> 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<uploaded_file> upfile = _upload_file(file, headers); netreturn<uploaded_file> upfile = _upload_file(file, headers);
netreturn<uploaded_audio> retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus()); netreturn<uploaded_audio> retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus());
retval.value().m_mimetype = file.mimetype; retval.value().m_mimetype = file.mimetype;
return retval; return retval;
} }
netreturn<uploaded_video> client::upload_video(const video_details& file)const{ netreturn<uploaded_video> 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<uploaded_file> upfile = _upload_file(file, headers); netreturn<uploaded_file> upfile = _upload_file(file, headers);
netreturn<uploaded_video> retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus()); netreturn<uploaded_video> retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus());
retval.value().m_width = file.width; 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){ static size_t _thumbnail_header_callback(char* ptr, size_t size, size_t nmemb, void* userdata){
raii::string* data = reinterpret_cast<raii::string*>(userdata); rexy::string* data = reinterpret_cast<rexy::string*>(userdata);
if(size*nmemb > 13 && !strncmp("Content-Type:", ptr, 13)){ if(size*nmemb > 13 && !strncmp("Content-Type:", ptr, 13)){
(*data) += (ptr + 13); (*data) += (ptr + 13);
data->get()[data->length()-1] = 0; data->get()[data->length()-1] = 0;
@ -137,7 +137,7 @@ namespace matrix{
netreturn<void> client::create_thumbnail(uploaded_image& info)const{ netreturn<void> client::create_thumbnail(uploaded_image& info)const{
image_details i; image_details i;
raii::string reply_header; rexy::string reply_header;
if(info.thumb_width() > info.width() || info.thumb_height() > info.height()){ if(info.thumb_width() > info.width() || info.thumb_height() > info.height()){
info.m_thumb.m_url = info.m_fileurl; info.m_thumb.m_url = info.m_fileurl;
info.m_thumb.m_size = info.m_filesize; info.m_thumb.m_size = info.m_filesize;
@ -149,7 +149,7 @@ namespace matrix{
m_curl.setopt(CURLOPT_HEADERFUNCTION, NULL); m_curl.setopt(CURLOPT_HEADERFUNCTION, NULL);
m_curl.setopt(CURLOPT_HEADERDATA, NULL); m_curl.setopt(CURLOPT_HEADERDATA, NULL);
if(!i.data) if(!i.data)
return netreturn<void>(raii::string(), raii::string(), http_status()); return netreturn<void>(rexy::string(), rexy::string(), http_status());
i.width = info.thumb_width(); i.width = info.thumb_width();
i.height = info.thumb_height(); i.height = info.thumb_height();
i.mimetype = std::move(reply_header); i.mimetype = std::move(reply_header);
@ -165,21 +165,21 @@ namespace matrix{
netreturn<void> client::create_thumbnail(uploaded_video& info)const{ netreturn<void> client::create_thumbnail(uploaded_video& info)const{
return create_thumbnail(static_cast<uploaded_image&>(info)); return create_thumbnail(static_cast<uploaded_image&>(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)); return _get_curl_binary(m_urls->file_download(*m_ses, url));
} }
netreturn<sync::client_response> client::sync(size_t timeout){ netreturn<sync::client_response> client::sync(size_t timeout){
return sync(timeout, {}); return sync(timeout, {});
} }
netreturn<sync::client_response> client::sync(size_t timeout, const sync::client_response& last){ netreturn<sync::client_response> client::sync(size_t timeout, const sync::client_response& last){
raii::string reply; rexy::string reply;
if(last.raw_handle()) if(last.raw_handle())
reply = _get_curl(m_urls->sync(*m_ses, last.next_batch(), raii::itostr(timeout))); reply = _get_curl(m_urls->sync(*m_ses, last.next_batch(), raii::itostr(timeout)));
else else
reply = _get_curl(m_urls->sync(*m_ses, ""_ss, raii::itostr(timeout))); reply = _get_curl(m_urls->sync(*m_ses, ""_ss, raii::itostr(timeout)));
if(!reply) if(!reply)
return netreturn<sync::client_response>(raii::string(), raii::string(), http_status(), {nullptr}); return netreturn<sync::client_response>(rexy::string(), rexy::string(), http_status(), {nullptr});
raii::rjp_ptr root(rjp_parse(reply)); raii::rjp_ptr root(rjp_parse(reply));
netreturn<sync::client_response> retval = _create_netreturn(root, http_status()); netreturn<sync::client_response> retval = _create_netreturn(root, http_status());
if(!root) if(!root)
@ -210,7 +210,7 @@ namespace matrix{
} }
netreturn<uploaded_file> client::_upload_file(const file_details& file, const raii::curl_llist& header)const{ netreturn<uploaded_file> 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()}; internal_upload_data upload_data = {file.data.get(), file.data.size()};
m_curl.postreq(); m_curl.postreq();
m_curl.setopt(CURLOPT_POSTFIELDS, NULL); m_curl.setopt(CURLOPT_POSTFIELDS, NULL);

64
src/matrix/connection.cpp
View File

@ -18,7 +18,7 @@
#include "matrix/connection.hpp" #include "matrix/connection.hpp"
#include "raii/rjp_ptr.hpp" #include "raii/rjp_ptr.hpp"
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
#include <cstdlib> //size_t #include <cstdlib> //size_t
#include <algorithm> //min, max #include <algorithm> //min, max
@ -37,7 +37,7 @@ namespace matrix{
const raii::rjp_string& connection::userid(void)const{ const raii::rjp_string& connection::userid(void)const{
return m_ses->userid; return m_ses->userid;
} }
const raii::string& connection::useragent(void)const{ const rexy::string& connection::useragent(void)const{
return m_ses->useragent; 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){ size_t connection::_reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata){
raii::string* data = reinterpret_cast<raii::string*>(userdata); rexy::string* data = reinterpret_cast<rexy::string*>(userdata);
data->append(ptr, size*nmemb); data->append(ptr, size*nmemb);
return size*nmemb; return size*nmemb;
} }
size_t connection::_binary_reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata){ size_t connection::_binary_reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata){
raii::binary* data = reinterpret_cast<raii::binary*>(userdata); rexy::binary* data = reinterpret_cast<rexy::binary*>(userdata);
data->append(ptr, size*nmemb); data->append(ptr, size*nmemb);
return 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.getreq();
m_curl.seturl(url); m_curl.seturl(url);
m_curl.setheader(raii::curl_llist{}); 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.postreq();
m_curl.setpostdata(postdata.get(), postdata.length()); m_curl.setpostdata(postdata.get(), postdata.length());
m_curl.seturl(url); m_curl.seturl(url);
@ -75,7 +75,7 @@ namespace matrix{
src->data += to_copy; src->data += to_copy;
return 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.putreq();
m_curl.setopt(CURLOPT_POSTFIELDS, data.data); m_curl.setopt(CURLOPT_POSTFIELDS, data.data);
m_curl.setopt(CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t)data.len); 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); 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); m_curl.setuseragent(useragent);
} }
bool connection::_perform_curl(void)const{ bool connection::_perform_curl(void)const{
CURLcode res = m_curl.perform(); CURLcode res = m_curl.perform();
return (res == CURLE_OK); return (res == CURLE_OK);
} }
raii::string connection::_get_curl(const raii::string_base& url, reply_callback_fun fun)const{ rexy::string connection::_get_curl(const rexy::string_base& url, reply_callback_fun fun)const{
raii::string reply; rexy::string reply;
_get_curl_setup(url); _get_curl_setup(url);
m_curl.setwritefun(fun); m_curl.setwritefun(fun);
m_curl.setwritedata(&reply); m_curl.setwritedata(&reply);
@ -102,8 +102,8 @@ namespace matrix{
return {}; return {};
return reply; return reply;
} }
raii::binary connection::_get_curl_binary(const raii::string_base& url, binary_callback_fun fun)const{ rexy::binary connection::_get_curl_binary(const rexy::string_base& url, binary_callback_fun fun)const{
raii::binary reply; rexy::binary reply;
_get_curl_setup(url); _get_curl_setup(url);
m_curl.setwritefun(fun); m_curl.setwritefun(fun);
m_curl.setwritedata(&reply); m_curl.setwritedata(&reply);
@ -111,8 +111,8 @@ namespace matrix{
return {}; return {};
return reply; 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{ 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{
raii::string reply; rexy::string reply;
_post_curl_setup(postdata, url, header); _post_curl_setup(postdata, url, header);
m_curl.setwritefun(fun); m_curl.setwritefun(fun);
m_curl.setwritedata(&reply); m_curl.setwritedata(&reply);
@ -120,8 +120,8 @@ namespace matrix{
return {}; return {};
return reply; 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{ 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{
raii::binary reply; rexy::binary reply;
_post_curl_setup(postdata, url, header); _post_curl_setup(postdata, url, header);
m_curl.setwritefun(fun); m_curl.setwritefun(fun);
m_curl.setwritedata(&reply); m_curl.setwritedata(&reply);
@ -129,8 +129,8 @@ namespace matrix{
return {}; return {};
return reply; 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{ 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{
raii::string reply; rexy::string reply;
put_data data{putdata.get(), putdata.length()}; put_data data{putdata.get(), putdata.length()};
m_curl.setwritefun(fun); m_curl.setwritefun(fun);
m_curl.setwritedata(&reply); m_curl.setwritedata(&reply);
@ -142,8 +142,8 @@ namespace matrix{
return {}; return {};
return reply; 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{ 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{
raii::binary reply; rexy::binary reply;
put_data data{putdata.get(), putdata.length()}; put_data data{putdata.get(), putdata.length()};
m_curl.setwritefun(fun); m_curl.setwritefun(fun);
m_curl.setwritedata(&reply); m_curl.setwritedata(&reply);
@ -155,10 +155,10 @@ namespace matrix{
return {}; return {};
return reply; return reply;
} }
netreturn<raii::rjp_string> connection::_post_and_find(const raii::string_base& data, const raii::string_base& url, netreturn<raii::rjp_string> connection::_post_and_find(const rexy::string_base& data, const rexy::string_base& url,
const raii::curl_llist& header, const raii::string_base& target)const 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) if(!reply)
return _create_netreturn(reply, http_status()); return _create_netreturn(reply, http_status());
raii::rjp_ptr root(rjp_parse(reply)); raii::rjp_ptr root(rjp_parse(reply));
@ -166,10 +166,10 @@ namespace matrix{
retval.value() = _curl_reply_search(reply, target); retval.value() = _curl_reply_search(reply, target);
return retval; return retval;
} }
netreturn<raii::rjp_string> connection::_put_and_find(const raii::string_base& data, const raii::string_base& url, netreturn<raii::rjp_string> connection::_put_and_find(const rexy::string_base& data, const rexy::string_base& url,
const raii::curl_llist& header, const raii::string_base& target)const 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) if(!reply)
return _create_netreturn(reply, http_status()); return _create_netreturn(reply, http_status());
raii::rjp_ptr root(rjp_parse(reply)); raii::rjp_ptr root(rjp_parse(reply));
@ -177,8 +177,8 @@ namespace matrix{
retval.value() = _curl_reply_search(reply, target); retval.value() = _curl_reply_search(reply, target);
return retval; return retval;
} }
netreturn<raii::rjp_string> connection::_get_and_find(const raii::string_base& url, const raii::string_base& target)const{ netreturn<raii::rjp_string> connection::_get_and_find(const rexy::string_base& url, const rexy::string_base& target)const{
raii::string reply = _get_curl(url); rexy::string reply = _get_curl(url);
if(!reply) if(!reply)
return _create_netreturn(reply, http_status()); return _create_netreturn(reply, http_status());
raii::rjp_ptr root(rjp_parse(reply)); raii::rjp_ptr root(rjp_parse(reply));
@ -186,11 +186,11 @@ namespace matrix{
retval.value() = _curl_reply_search(reply, target); retval.value() = _curl_reply_search(reply, target);
return retval; 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)); raii::rjp_ptr root(rjp_parse(reply));
return _curl_reply_search(root, target); 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) if(!root)
return {}; return {};
RJP_value* res = rjp_search_member(root.get(), target.get()); RJP_value* res = rjp_search_member(root.get(), target.get());
@ -201,7 +201,7 @@ namespace matrix{
return raii::rjp_string(res); 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 #ifdef _WIN32
//temporary measure to make ssl connections work on wine //temporary measure to make ssl connections work on wine
m_curl.setopt(CURLOPT_CAINFO, "./cacert.pem"); m_curl.setopt(CURLOPT_CAINFO, "./cacert.pem");
@ -215,7 +215,7 @@ namespace matrix{
m_curl.setopt(CURLOPT_TCP_KEEPALIVE, 1L); m_curl.setopt(CURLOPT_TCP_KEEPALIVE, 1L);
//m_curl.setopt(CURLOPT_FAILONERROR, 0L); //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) if(!mxjson)
return netreturn_base(""_ss, ""_ss, httpstatus); return netreturn_base(""_ss, ""_ss, httpstatus);
raii::rjp_ptr root(rjp_parse(mxjson.get())); raii::rjp_ptr root(rjp_parse(mxjson.get()));

42
src/matrix/events.cpp
View File

@ -30,8 +30,8 @@ namespace matrix::sync{
m_event(std::exchange(ev.m_event, nullptr)), m_event(std::exchange(ev.m_event, nullptr)),
m_type(std::exchange(ev.m_type, nullptr)), m_type(std::exchange(ev.m_type, nullptr)),
m_content(std::exchange(ev.m_content, nullptr)){} m_content(std::exchange(ev.m_content, nullptr)){}
raii::static_string event::type(void)const&{ rexy::static_string event::type(void)const&{
return raii::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length); return rexy::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length);
} }
raii::rjp_string event::type(void)&&{ raii::rjp_string event::type(void)&&{
return raii::rjp_string(std::exchange(m_type, nullptr)); return raii::rjp_string(std::exchange(m_type, nullptr));
@ -50,7 +50,7 @@ namespace matrix::sync{
} }
//Room event //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) room_event_base(roomid), event(ev)
{ {
if(!ev) if(!ev)
@ -68,15 +68,15 @@ namespace matrix::sync{
m_unsigned(std::exchange(ev.m_unsigned, nullptr)), m_unsigned(std::exchange(ev.m_unsigned, nullptr)),
m_redacts(std::exchange(ev.m_redacts, nullptr)), m_redacts(std::exchange(ev.m_redacts, nullptr)),
m_origin_server_ts(ev.m_origin_server_ts){} m_origin_server_ts(ev.m_origin_server_ts){}
raii::static_string room_event::eventid(void)const&{ rexy::static_string room_event::eventid(void)const&{
return raii::static_string(rjp_get_cstring(m_id)->value, rjp_get_cstring(m_id)->length); return rexy::static_string(rjp_get_cstring(m_id)->value, rjp_get_cstring(m_id)->length);
} }
raii::rjp_string room_event::eventid(void)&&{ raii::rjp_string room_event::eventid(void)&&{
return raii::rjp_string(std::exchange(m_id, nullptr)); return raii::rjp_string(std::exchange(m_id, nullptr));
} }
raii::static_string room_event::sender(void)const&{ rexy::static_string room_event::sender(void)const&{
return raii::static_string(rjp_get_cstring(m_sender)->value, rjp_get_cstring(m_sender)->length); return rexy::static_string(rjp_get_cstring(m_sender)->value, rjp_get_cstring(m_sender)->length);
} }
raii::rjp_string room_event::sender(void)&&{ raii::rjp_string room_event::sender(void)&&{
return raii::rjp_string(std::exchange(m_sender, nullptr)); return raii::rjp_string(std::exchange(m_sender, nullptr));
@ -90,10 +90,10 @@ namespace matrix::sync{
RJP_value* room_event::extra(void){ RJP_value* room_event::extra(void){
return m_unsigned; return m_unsigned;
} }
raii::static_string room_event::redacts(void)const&{ rexy::static_string room_event::redacts(void)const&{
if(!m_redacts) if(!m_redacts)
return raii::static_string(); return rexy::static_string();
return raii::static_string(rjp_get_cstring(m_redacts)->value, rjp_get_cstring(m_redacts)->length); return rexy::static_string(rjp_get_cstring(m_redacts)->value, rjp_get_cstring(m_redacts)->length);
} }
raii::rjp_string room_event::redacts(void)&&{ raii::rjp_string room_event::redacts(void)&&{
if(!m_redacts) if(!m_redacts)
@ -102,7 +102,7 @@ namespace matrix::sync{
} }
//Room state event //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) room_event(ev, roomid)
{ {
if(!ev) if(!ev)
@ -113,24 +113,24 @@ namespace matrix::sync{
m_prev_content = rjp_search_member(m_unsigned, json::keys::event::prev_content()); m_prev_content = rjp_search_member(m_unsigned, json::keys::event::prev_content());
} }
} }
raii::static_string room_state_event::state_key(void)const&{ rexy::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); 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)&&{ raii::rjp_string room_state_event::state_key(void)&&{
return raii::rjp_string(std::exchange(m_state_key, nullptr)); return raii::rjp_string(std::exchange(m_state_key, nullptr));
} }
raii::static_string room_state_event::prev_content(void)const&{ rexy::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); 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)&&{ raii::rjp_string room_state_event::prev_content(void)&&{
return raii::rjp_string(std::exchange(m_prev_content, nullptr)); 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_event_base(roomid), event(ev){}
//Room message event //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), room_event(ev, roomid),
m_body(rjp_search_member(m_content, json::keys::event::contentbody::body())), m_body(rjp_search_member(m_content, json::keys::event::contentbody::body())),
m_type(rjp_search_member(m_content, json::keys::event::contentbody::msgtype())){} m_type(rjp_search_member(m_content, json::keys::event::contentbody::msgtype())){}
@ -138,14 +138,14 @@ namespace matrix::sync{
room_event(std::move(ev)), room_event(std::move(ev)),
m_body(rjp_search_member(m_content, json::keys::event::contentbody::body())), m_body(rjp_search_member(m_content, json::keys::event::contentbody::body())),
m_type(rjp_search_member(m_content, json::keys::event::contentbody::msgtype())){} m_type(rjp_search_member(m_content, json::keys::event::contentbody::msgtype())){}
raii::static_string room_message_event::body(void)const&{ rexy::static_string room_message_event::body(void)const&{
return raii::static_string(rjp_get_cstring(m_body)->value, rjp_get_cstring(m_body)->length); return rexy::static_string(rjp_get_cstring(m_body)->value, rjp_get_cstring(m_body)->length);
} }
raii::rjp_string room_message_event::body(void)&&{ raii::rjp_string room_message_event::body(void)&&{
return raii::rjp_string(m_body); return raii::rjp_string(m_body);
} }
raii::static_string room_message_event::msgtype(void)const&{ rexy::static_string room_message_event::msgtype(void)const&{
return raii::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length); return rexy::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length);
} }
raii::rjp_string room_message_event::msgtype(void)&&{ raii::rjp_string room_message_event::msgtype(void)&&{
return raii::rjp_string(m_type); return raii::rjp_string(m_type);

88
src/matrix/fat_strings.cpp
View File

@ -18,24 +18,24 @@
#include "matrix/fat_strings.hpp" #include "matrix/fat_strings.hpp"
#include "matrix/upload_info.hpp" #include "matrix/upload_info.hpp"
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
#include "matrix/json_targets.hpp" #include "matrix/json_targets.hpp"
#include "raii/util.hpp" #include "raii/util.hpp"
namespace matrix::json{ namespace matrix::json{
static constexpr auto quote(const raii::string_base& str){ static constexpr auto quote(const rexy::string_base& str){
return "\"" + str + "\""; return "\"" + str + "\"";
} }
static constexpr auto key(const raii::string_base& str){ static constexpr auto key(const rexy::string_base& str){
return "\"" + str + "\":"; return "\"" + str + "\":";
} }
static constexpr raii::static_string open_brace(void){ static constexpr rexy::static_string open_brace(void){
return "{"_ss; return "{"_ss;
} }
static constexpr raii::static_string close_brace(void){ static constexpr rexy::static_string close_brace(void){
return "}"_ss; return "}"_ss;
} }
static constexpr raii::static_string comma(void){ static constexpr rexy::static_string comma(void){
return ","_ss; return ","_ss;
} }
template<class Arg, class... Args> template<class Arg, class... Args>
@ -55,18 +55,18 @@ namespace matrix::json{
return key(k) + value; return key(k) + value;
} }
raii::static_string _empty(void){ rexy::static_string _empty(void){
return "{}"_ss; return "{}"_ss;
} }
raii::string _image_body(const uploaded_image& image){ rexy::string _image_body(const uploaded_image& image){
raii::string url = raii::json_escape(image.url()); rexy::string url = raii::json_escape(image.url());
const raii::string_base* thumburl; const rexy::string_base* thumburl;
if(image.thumb_url()) if(image.thumb_url())
thumburl = &image.thumb_url(); thumburl = &image.thumb_url();
else else
thumburl = &url; thumburl = &url;
return raii::string( return rexy::string(
object( object(
member(json::keys::event::contentbody::body(), quote(raii::json_escape(image.name()))), member(json::keys::event::contentbody::body(), quote(raii::json_escape(image.name()))),
member(json::keys::event::contentbody::info(), object( member(json::keys::event::contentbody::info(), object(
@ -87,8 +87,8 @@ namespace matrix::json{
)); ));
} }
raii::string _video_body(const uploaded_video& video){ rexy::string _video_body(const uploaded_video& video){
return raii::string( return rexy::string(
object( object(
member(json::keys::event::contentbody::body(), quote(raii::json_escape(video.name()))), member(json::keys::event::contentbody::body(), quote(raii::json_escape(video.name()))),
member(json::keys::event::contentbody::info(), object( 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()))) member(json::keys::event::contentbody::url(), quote(raii::json_escape(video.url())))
)); ));
} }
raii::string _file_body(const uploaded_file& file){ rexy::string _file_body(const uploaded_file& file){
return raii::string( return rexy::string(
object( object(
member(json::keys::event::contentbody::body(), quote(raii::json_escape(file.name()))), member(json::keys::event::contentbody::body(), quote(raii::json_escape(file.name()))),
member(json::keys::event::contentbody::info(), object( member(json::keys::event::contentbody::info(), object(
@ -120,8 +120,8 @@ namespace matrix::json{
)); ));
} }
raii::string _audio_body(const uploaded_audio& audio){ rexy::string _audio_body(const uploaded_audio& audio){
return raii::string( return rexy::string(
object( object(
member(json::keys::event::contentbody::body(), quote(raii::json_escape(audio.name()))), member(json::keys::event::contentbody::body(), quote(raii::json_escape(audio.name()))),
member(json::keys::event::contentbody::info(), object( member(json::keys::event::contentbody::info(), object(
@ -133,22 +133,22 @@ namespace matrix::json{
)); ));
} }
raii::string _message_body(const raii::string_base& msg){ rexy::string _message_body(const rexy::string_base& msg){
return raii::string( return rexy::string(
object( object(
member(json::keys::event::contentbody::body(), quote(raii::json_escape(msg))), member(json::keys::event::contentbody::body(), quote(raii::json_escape(msg))),
member(json::keys::event::contentbody::msgtype(), quote("m.text"_ss)) member(json::keys::event::contentbody::msgtype(), quote("m.text"_ss))
)); ));
} }
raii::string _notice_body(const raii::string_base& msg){ rexy::string _notice_body(const rexy::string_base& msg){
return raii::string( return rexy::string(
object( object(
member(json::keys::event::contentbody::body(), quote(raii::json_escape(msg))), member(json::keys::event::contentbody::body(), quote(raii::json_escape(msg))),
member(json::keys::event::contentbody::msgtype(), quote("m.notice"_ss)) member(json::keys::event::contentbody::msgtype(), quote("m.notice"_ss))
)); ));
} }
raii::string _login_password(const raii::string_base& username, const raii::string_base& password){ rexy::string _login_password(const rexy::string_base& username, const rexy::string_base& password){
return raii::string( return rexy::string(
object( object(
member(json::keys::auth::type(), quote("m.login.password"_ss)), member(json::keys::auth::type(), quote("m.login.password"_ss)),
member(json::keys::auth::identifier(), object( member(json::keys::auth::identifier(), object(
@ -158,8 +158,8 @@ namespace matrix::json{
member(json::keys::auth::password(), quote(raii::json_escape(password))) 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){ 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 raii::string( return rexy::string(
object( object(
member(json::keys::auth::newpassword(), quote(raii::json_escape(newpass))), member(json::keys::auth::newpassword(), quote(raii::json_escape(newpass))),
member(json::keys::auth::auth(), object( member(json::keys::auth::auth(), object(
@ -170,66 +170,66 @@ namespace matrix::json{
)) ))
)); ));
} }
raii::string _displayname_set(const raii::string_base& newname){ rexy::string _displayname_set(const rexy::string_base& newname){
return raii::string( return rexy::string(
object( object(
member(json::keys::displayname(), quote(raii::json_escape(newname))) member(json::keys::displayname(), quote(raii::json_escape(newname)))
)); ));
} }
raii::string _avatar_set(const raii::string_base& mediaurl){ rexy::string _avatar_set(const rexy::string_base& mediaurl){
return raii::string( return rexy::string(
object( object(
member(json::keys::avatarurl(), quote(raii::json_escape(mediaurl))) member(json::keys::avatarurl(), quote(raii::json_escape(mediaurl)))
)); ));
} }
raii::string _presence_set(const raii::string_base& status){ rexy::string _presence_set(const rexy::string_base& status){
return raii::string( return rexy::string(
object( object(
member(json::keys::presence(), quote(status)) 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){ if(alias){
return raii::string( return rexy::string(
object( object(
member(json::keys::name(), quote(raii::json_escape(name))), member(json::keys::name(), quote(raii::json_escape(name))),
member(json::keys::roomaliasname(), quote(raii::json_escape(alias))) member(json::keys::roomaliasname(), quote(raii::json_escape(alias)))
)); ));
}else{ }else{
return raii::string( return rexy::string(
object( object(
member(json::keys::name(), quote(raii::json_escape(name))) member(json::keys::name(), quote(raii::json_escape(name)))
)); ));
} }
} }
raii::string _userid(const raii::string_base& id){ rexy::string _userid(const rexy::string_base& id){
return raii::string( return rexy::string(
object( object(
member(json::keys::auth::userid(), quote(raii::json_escape(id))) member(json::keys::auth::userid(), quote(raii::json_escape(id)))
)); ));
} }
raii::string _userid_reason(const raii::string_base& id, const raii::string_base& reason){ rexy::string _userid_reason(const rexy::string_base& id, const rexy::string_base& reason){
return raii::string( return rexy::string(
object( object(
member(json::keys::auth::userid(), quote(raii::json_escape(id))), member(json::keys::auth::userid(), quote(raii::json_escape(id))),
member(json::reason(), quote(raii::json_escape(reason))) member(json::reason(), quote(raii::json_escape(reason)))
)); ));
} }
raii::string _typing(bool active, int timeout){ rexy::string _typing(bool active, int timeout){
return raii::string( return rexy::string(
object( object(
member(json::keys::typing(), active ? json::True() : json::False()), member(json::keys::typing(), active ? json::True() : json::False()),
member(json::keys::timeout(), raii::itostr(timeout)) member(json::keys::timeout(), raii::itostr(timeout))
)); ));
} }
raii::string _redact(const raii::string_base& reason){ rexy::string _redact(const rexy::string_base& reason){
return raii::string( return rexy::string(
object( object(
member(json::reason(), quote(raii::json_escape(reason))) member(json::reason(), quote(raii::json_escape(reason)))
)); ));
} }
raii::string _room_upgrade(int version){ rexy::string _room_upgrade(int version){
return raii::string( return rexy::string(
object( object(
member(json::keys::newversion(), raii::itostr(version)) member(json::keys::newversion(), raii::itostr(version))
)); ));

10
src/matrix/iterable.cpp
View File

@ -20,22 +20,22 @@
namespace matrix::sync{ namespace matrix::sync{
template<class T> template<class T>
roomcxn_event_list_base<T>::roomcxn_event_list_base(raii::rjp_ptr& root, RJP_value* event, const raii::string_base& roomid): roomcxn_event_list_base<T>::roomcxn_event_list_base(raii::rjp_ptr& root, RJP_value* event, const rexy::string_base& roomid):
iterable_room_event_base<detail::room_event_iterator<T>>(event, roomid), iterable_room_event_base<detail::room_event_iterator<T>>(event, roomid),
m_root(root.release()){} m_root(root.release()){}
template<class T> template<class T>
raii::static_string roomcxn_event_list_base<T>::start_token(void)const&{ rexy::static_string roomcxn_event_list_base<T>::start_token(void)const&{
RJP_value* st = rjp_search_member(m_root.get(), "start"); 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<class T> template<class T>
raii::rjp_string roomcxn_event_list_base<T>::start_token(void)&&{ raii::rjp_string roomcxn_event_list_base<T>::start_token(void)&&{
return raii::rjp_string(rjp_search_member(m_root.get(), "start")); return raii::rjp_string(rjp_search_member(m_root.get(), "start"));
} }
template<class T> template<class T>
raii::static_string roomcxn_event_list_base<T>::end_token(void)const&{ rexy::static_string roomcxn_event_list_base<T>::end_token(void)const&{
RJP_value* st = rjp_search_member(m_root.get(), "end"); 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<class T> template<class T>
raii::rjp_string roomcxn_event_list_base<T>::end_token(void)&&{ raii::rjp_string roomcxn_event_list_base<T>::end_token(void)&&{

42
src/matrix/rest/client_url_list.cpp
View File

@ -17,7 +17,7 @@
*/ */
#include "matrix/rest/client_url_list.hpp" #include "matrix/rest/client_url_list.hpp"
#include "raii/string.hpp" #include <rexy/string.hpp>
#include "raii/util.hpp" #include "raii/util.hpp"
namespace matrix::rest{ namespace matrix::rest{
@ -25,41 +25,41 @@ namespace matrix::rest{
client_url_list::client_url_list(const session_info& session){ client_url_list::client_url_list(const session_info& session){
repopulate(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; 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; 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; 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; 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; return m_profile_picture;
} }
raii::string client_url_list::displayname(const session_info& session, const raii::string_base& userid)const{ rexy::string client_url_list::displayname(const session_info& session, const rexy::string_base& userid)const{
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/profile/" + userid + "/displayname?access_token=" + session.access_token); 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){ rexy::string client_url_list::file_download(const session_info& session, const rexy::string_base& fileurl){
raii::string media = get_server_media_string(fileurl); rexy::string media = get_server_media_string(fileurl);
if(!media) return {}; 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{ 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{
raii::string media = get_server_media_string(fileurl); rexy::string media = get_server_media_string(fileurl);
if(!media) return {}; 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{ rexy::string client_url_list::presence(const session_info& session, const rexy::string_base& userid)const{
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/presence/" + userid + "/status?access_token=" + session.access_token); 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) if(!next_batch)
return raii::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);
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 + "&since=" + next_batch);
} }
void client_url_list::repopulate(const session_info& session){ void client_url_list::repopulate(const session_info& session){
@ -77,11 +77,11 @@ namespace matrix::rest{
m_alias_lookup.reset(); 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)) if(!url || strncmp(url.get(), "mxc://", 6))
return {}; return {};
return raii::string(url.get()+6, url.length()-6); return rexy::string(url.get()+6, url.length()-6);
} }
} }

62
src/matrix/rest/room_url_list.cpp
View File

@ -21,68 +21,68 @@
namespace matrix{ 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_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_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_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_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_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){} 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{ rexy::string room_url_list::join(const session_info& session, const rexy::string_base& roomid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/leave?access_token=" + session.access_token); 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{ rexy::string room_url_list::leave(const session_info& session, const rexy::string_base& roomid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/join?access_token=" + session.access_token); 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{ rexy::string room_url_list::forget(const session_info& session, const rexy::string_base& roomid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/forget?access_token=" + session.access_token); 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{ rexy::string room_url_list::upgrade(const session_info& session, const rexy::string_base& roomid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/upgrade?access_token=" + session.access_token); 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{ rexy::string room_url_list::read_receipt(const session_info& session, const rexy::string_base& roomid, const rexy::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); 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{ rexy::string room_url_list::send(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventtype)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/send/" + eventtype + "?access_token=" + session.access_token); 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{ rexy::string room_url_list::redact(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/redact/" + eventid + "/0?access_token=" + session.access_token); 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{ rexy::string room_url_list::event(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const{
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/event/" + eventid + "?access_token=" + session.access_token); 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{ rexy::string room_url_list::power_level(const session_info& session, const rexy::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); 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; return m_typing;
} }
const raii::string& room_url_list::kick(void)const{ const rexy::string& room_url_list::kick(void)const{
return m_kick; return m_kick;
} }
const raii::string& room_url_list::ban(void)const{ const rexy::string& room_url_list::ban(void)const{
return m_ban; return m_ban;
} }
const raii::string& room_url_list::unban(void)const{ const rexy::string& room_url_list::unban(void)const{
return m_unban; return m_unban;
} }
const raii::string& room_url_list::invite(void)const{ const rexy::string& room_url_list::invite(void)const{
return m_invite; 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; return m_members;
} }
raii::string room_url_list::messages(const session_info& session, const raii::string_base& roomid, rexy::string room_url_list::messages(const session_info& session, const rexy::string_base& roomid,
const raii::string_base& from, const raii::string_base& to, const rexy::string_base& from, const rexy::string_base& to,
const raii::string_base& dir, int limit)const const rexy::string_base& dir, int limit)const
{ {
if(to) 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 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_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_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_ban = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/ban?access_token=" + session.access_token;

16
src/matrix/rest/session_urls.cpp
View File

@ -19,16 +19,16 @@
#include "matrix/rest/session_urls.hpp" #include "matrix/rest/session_urls.hpp"
namespace matrix::rest::session_urls{ namespace matrix::rest::session_urls{
raii::string login(const session_info& session){ rexy::string login(const session_info& session){
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/login"); return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/login");
} }
raii::string logout(const session_info& session){ rexy::string logout(const session_info& session){
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/logout?access_token=" + session.access_token); return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/logout?access_token=" + session.access_token);
} }
raii::string password(const session_info& session){ rexy::string password(const session_info& session){
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/account/password?access_token=" + session.access_token); 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){ rexy::string whoami(const session_info& session){
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/account/whoami?access_token=" + session.access_token); return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/account/whoami?access_token=" + session.access_token);
} }
} }

70
src/matrix/roomcxn.cpp
View File

@ -17,7 +17,7 @@
*/ */
#include "matrix/roomcxn.hpp" #include "matrix/roomcxn.hpp"
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
#include "matrix/fat_strings.hpp" #include "matrix/fat_strings.hpp"
#include "matrix/json_targets.hpp" #include "matrix/json_targets.hpp"
#include "raii/util.hpp" #include "raii/util.hpp"
@ -26,23 +26,23 @@
namespace matrix{ namespace matrix{
roomcxn::roomcxn(const std::shared_ptr<session_info>& ses, const raii::string_base& roomid): roomcxn::roomcxn(const std::shared_ptr<session_info>& ses, const rexy::string_base& roomid):
roomcxn(ses, raii::string(roomid)){} roomcxn(ses, rexy::string(roomid)){}
roomcxn::roomcxn(const std::shared_ptr<session_info>& ses, raii::string&& roomid): roomcxn::roomcxn(const std::shared_ptr<session_info>& ses, rexy::string&& roomid):
connection(ses), connection(ses),
m_roomid(std::move(roomid)), m_roomid(std::move(roomid)),
m_urls(*ses, m_curl.encode(m_roomid)){} m_urls(*ses, m_curl.encode(m_roomid)){}
netreturn<void> roomcxn::join(void)const{ netreturn<void> 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()); return _create_netreturn(response, http_status());
} }
netreturn<void> roomcxn::leave(void)const{ netreturn<void> 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()); return _create_netreturn(response, http_status());
} }
netreturn<void> roomcxn::forget(void)const{ netreturn<void> 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()); return _create_netreturn(response, http_status());
} }
netreturn<void> roomcxn::accept_invite(void)const{ netreturn<void> roomcxn::accept_invite(void)const{
@ -55,7 +55,7 @@ namespace matrix{
netreturn<std::vector<raii::rjp_string>> roomcxn::members(void)const{ netreturn<std::vector<raii::rjp_string>> roomcxn::members(void)const{
netreturn<std::vector<raii::rjp_string>> retval; netreturn<std::vector<raii::rjp_string>> 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()); if(!resp) return _create_netreturn(resp, http_status());
raii::rjp_ptr root(rjp_parse(resp.get())); raii::rjp_ptr root(rjp_parse(resp.get()));
if(!root) return _create_netreturn(root, http_status()); if(!root) return _create_netreturn(root, http_status());
@ -69,17 +69,17 @@ namespace matrix{
} }
return retval; return retval;
} }
netreturn<void> roomcxn::invite(const raii::string_base& userid){ netreturn<void> roomcxn::invite(const rexy::string_base& userid){
raii::string json(json::_userid(userid)); rexy::string json(json::_userid(userid));
printf("%s\n", json.get()); 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()); return _create_netreturn(response, http_status());
} }
netreturn<void> roomcxn::uninvite(const raii::string_base& userid, const raii::string_base& reason){ netreturn<void> roomcxn::uninvite(const rexy::string_base& userid, const rexy::string_base& reason){
return kick(userid, reason); return kick(userid, reason);
} }
netreturn<void> roomcxn::kick(const raii::string_base& userid, const raii::string_base& reason){ netreturn<void> roomcxn::kick(const rexy::string_base& userid, const rexy::string_base& reason){
raii::string response; rexy::string response;
if(reason){ if(reason){
response = _post_curl(json::_userid_reason(userid, reason), m_urls.kick(), raii::curl_llist()); response = _post_curl(json::_userid_reason(userid, reason), m_urls.kick(), raii::curl_llist());
}else{ }else{
@ -87,8 +87,8 @@ namespace matrix{
} }
return _create_netreturn(response, http_status()); return _create_netreturn(response, http_status());
} }
netreturn<void> roomcxn::ban(const raii::string_base& userid, const raii::string_base& reason){ netreturn<void> roomcxn::ban(const rexy::string_base& userid, const rexy::string_base& reason){
raii::string response; rexy::string response;
if(reason){ if(reason){
response = _post_curl(json::_userid_reason(userid, reason), m_urls.ban(), raii::curl_llist()); response = _post_curl(json::_userid_reason(userid, reason), m_urls.ban(), raii::curl_llist());
}else{ }else{
@ -96,14 +96,14 @@ namespace matrix{
} }
return _create_netreturn(response, http_status()); return _create_netreturn(response, http_status());
} }
netreturn<void> roomcxn::unban(const raii::string_base& userid){ netreturn<void> roomcxn::unban(const rexy::string_base& userid){
raii::string response = _post_curl(json::_userid(userid), m_urls.unban(), raii::curl_llist()); rexy::string response = _post_curl(json::_userid(userid), m_urls.unban(), raii::curl_llist());
return _create_netreturn(response, http_status()); return _create_netreturn(response, http_status());
} }
netreturn<raii::rjp_string> roomcxn::send_custom_event(const raii::string_base& event, const raii::string_base& eventtype)const{ netreturn<raii::rjp_string> roomcxn::send_custom_event(const rexy::string_base& event, const rexy::string_base& eventtype)const{
raii::string reply = _post_curl(event, m_urls.send(*m_ses, m_curl.encode(m_roomid), eventtype), raii::curl_llist()); rexy::string reply = _post_curl(event, m_urls.send(*m_ses, m_curl.encode(m_roomid), eventtype), raii::curl_llist());
if(!reply) if(!reply)
return _create_netreturn(reply, http_status()); return _create_netreturn(reply, http_status());
@ -112,10 +112,10 @@ namespace matrix{
retval.value() = _curl_reply_search(root, json::keys::event::eventid()); retval.value() = _curl_reply_search(root, json::keys::event::eventid());
return retval; return retval;
} }
netreturn<raii::rjp_string> roomcxn::send_message(const raii::string_base& text)const{ netreturn<raii::rjp_string> roomcxn::send_message(const rexy::string_base& text)const{
return _send_message(json::_message_body(text)); return _send_message(json::_message_body(text));
} }
netreturn<raii::rjp_string> roomcxn::send_notice(const raii::string_base& text)const{ netreturn<raii::rjp_string> roomcxn::send_notice(const rexy::string_base& text)const{
return _send_message(json::_notice_body(text)); return _send_message(json::_notice_body(text));
} }
netreturn<raii::rjp_string> roomcxn::send_file(const uploaded_file& file)const{ netreturn<raii::rjp_string> roomcxn::send_file(const uploaded_file& file)const{
@ -137,12 +137,12 @@ namespace matrix{
netreturn<void> roomcxn::send_typing(bool active, int timeout)const{ netreturn<void> 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()); return _create_netreturn(_put_curl(json::_typing(active, timeout), m_urls.typing(), raii::curl_llist()), http_status());
} }
netreturn<void> roomcxn::send_read_receipt(const raii::string_base& eventid)const{ netreturn<void> roomcxn::send_read_receipt(const rexy::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()); 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<sync::roomcxn_message_event_list> roomcxn::get_event(const raii::string_base& eventid)const{ netreturn<sync::roomcxn_message_event_list> roomcxn::get_event(const rexy::string_base& eventid)const{
raii::string reply = _get_curl(m_urls.event(*m_ses, m_curl.encode(m_roomid), eventid)); rexy::string reply = _get_curl(m_urls.event(*m_ses, m_curl.encode(m_roomid), eventid));
if(!reply) return _create_netreturn(reply, http_status()); if(!reply) return _create_netreturn(reply, http_status());
raii::rjp_ptr root(rjp_parse(reply.get())); raii::rjp_ptr root(rjp_parse(reply.get()));
if(!root.get()) _create_netreturn(root, http_status()); 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); retval.value() = sync::roomcxn_message_event_list(root, root.get(), m_roomid);
return retval; return retval;
} }
netreturn<raii::rjp_string> roomcxn::redact_event(const raii::string_base& eventid, const raii::string_base& reason)const{ netreturn<raii::rjp_string> 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()); 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<raii::rjp_string> roomcxn::redact_event(const raii::string_base& eventid)const{ netreturn<raii::rjp_string> roomcxn::redact_event(const rexy::string_base& eventid)const{
return redact_event(eventid, "No reason given"_ss); return redact_event(eventid, "No reason given"_ss);
} }
netreturn<sync::roomcxn_message_event_list> roomcxn::_get_events(int amount, raii::static_string direction, const raii::string_base& from, const raii::string_base& to){ netreturn<sync::roomcxn_message_event_list> roomcxn::_get_events(int amount, rexy::static_string direction, const rexy::string_base& from, const rexy::string_base& to){
raii::string reply = _get_curl(m_urls.messages(*m_ses, m_curl.encode(m_roomid), from, to, direction, amount)); 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()); if(!reply) return _create_netreturn(reply, http_status());
raii::rjp_ptr root(rjp_parse(reply.get())); raii::rjp_ptr root(rjp_parse(reply.get()));
if(!root.get()) _create_netreturn(root, http_status()); if(!root.get()) _create_netreturn(root, http_status());
@ -171,15 +171,15 @@ namespace matrix{
return retval; return retval;
} }
netreturn<sync::roomcxn_message_event_list> roomcxn::get_events_forward(int amount){ netreturn<sync::roomcxn_message_event_list> 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<sync::roomcxn_message_event_list> roomcxn::get_events_backward(int amount){ netreturn<sync::roomcxn_message_event_list> 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<sync::roomcxn_message_event_list> roomcxn::get_events_forward(int amount, const raii::string_base& from, const raii::string_base& to){ netreturn<sync::roomcxn_message_event_list> roomcxn::get_events_forward(int amount, const rexy::string_base& from, const rexy::string_base& to){
return _get_events(amount, "f"_ss, from, to); return _get_events(amount, "f"_ss, from, to);
} }
netreturn<sync::roomcxn_message_event_list> roomcxn::get_events_backward(int amount, const raii::string_base& from, const raii::string_base& to){ netreturn<sync::roomcxn_message_event_list> roomcxn::get_events_backward(int amount, const rexy::string_base& from, const rexy::string_base& to){
return _get_events(amount, "b"_ss, from, 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()); return _post_and_find(json::_room_upgrade(version), m_urls.upgrade(*m_ses, m_roomid), raii::curl_llist(), json::keys::event::eventid());
} }
netreturn<raii::rjp_string> roomcxn::_send_message(const raii::string_base& msg)const{ netreturn<raii::rjp_string> roomcxn::_send_message(const rexy::string_base& msg)const{
return send_custom_event(msg, "m.room.message"_ss); return send_custom_event(msg, "m.room.message"_ss);
} }
} }

42
src/matrix/session.cpp
View File

@ -20,15 +20,15 @@
#include "raii/rjp_ptr.hpp" #include "raii/rjp_ptr.hpp"
#include "raii/curler.hpp" #include "raii/curler.hpp"
#include "raii/util.hpp" #include "raii/util.hpp"
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
#include "matrix/fat_strings.hpp" #include "matrix/fat_strings.hpp"
#include "matrix/json_targets.hpp" #include "matrix/json_targets.hpp"
#include "matrix/rest/session_urls.hpp" #include "matrix/rest/session_urls.hpp"
namespace matrix{ namespace matrix{
static raii::string create_auth_header(const raii::string_base& token){ static rexy::string create_auth_header(const rexy::string_base& token){
return raii::string("Authorization: Bearer " + token); return rexy::string("Authorization: Bearer " + token);
} }
session::session(void): session::session(void):
@ -43,43 +43,43 @@ namespace matrix{
invalidate(); invalidate();
} }
void session::set_useragent(const raii::string_base& agent){ void session::set_useragent(const rexy::string_base& agent){
m_ses->useragent = 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); 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; m_ses->homeserver = hs;
} }
void session::set_homeserver(raii::string&& hs){ void session::set_homeserver(rexy::string&& hs){
m_ses->homeserver = std::move(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->access_token = tok;
m_ses->auth_header = create_auth_header(m_ses->access_token); 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->access_token = std::move(tok);
m_ses->auth_header = create_auth_header(m_ses->access_token); m_ses->auth_header = create_auth_header(m_ses->access_token);
} }
netreturn<void> session::login(void){ netreturn<void> session::login(void){
return _do_login(raii::string(), raii::string()); return _do_login(rexy::string(), rexy::string());
} }
netreturn<void> session::login(const raii::string_base& username, const raii::string_base& pass){ netreturn<void> session::login(const rexy::string_base& username, const rexy::string_base& pass){
return _do_login(username, pass); return _do_login(username, pass);
} }
netreturn<void> session::logout(void){ netreturn<void> 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()); return _create_netreturn(reply, http_status());
} }
bool session::valid(void)const{ bool session::valid(void)const{
return m_valid; return m_valid;
} }
netreturn<void> session::change_password(const raii::string_base& oldpass, const raii::string_base& newpass){ netreturn<void> session::change_password(const rexy::string_base& oldpass, const rexy::string_base& newpass){
raii::string reply = _post_curl(json::_empty(), rest::session_urls::password(*m_ses), raii::curl_llist()); rexy::string reply = _post_curl(json::_empty(), rest::session_urls::password(*m_ses), raii::curl_llist());
if(!reply) if(!reply)
return _create_netreturn(reply, http_status()); return _create_netreturn(reply, http_status());
raii::rjp_ptr root(rjp_parse(reply)); raii::rjp_ptr root(rjp_parse(reply));
@ -89,7 +89,7 @@ namespace matrix{
//attempt to change password via username/password login //attempt to change password via username/password login
RJP_value* res = rjp_search_member(root.get(), json::keys::session()); 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()); reply = _post_curl(request, rest::session_urls::password(*m_ses), raii::curl_llist());
return _create_netreturn(reply, http_status()); return _create_netreturn(reply, http_status());
} }
@ -104,7 +104,7 @@ namespace matrix{
m_ses->userid.reset(); m_ses->userid.reset();
} }
netreturn<void> session::_do_login(const raii::string_base& username, const raii::string_base& pass){ netreturn<void> session::_do_login(const rexy::string_base& username, const rexy::string_base& pass){
auto reply = _get_curl(rest::session_urls::whoami(*m_ses)); auto reply = _get_curl(rest::session_urls::whoami(*m_ses));
netreturn<void> retval = _create_netreturn(reply, http_status()); netreturn<void> retval = _create_netreturn(reply, http_status());
if(!retval.ok()){ if(!retval.ok()){
@ -143,16 +143,16 @@ namespace matrix{
m_ses->auth_header = create_auth_header(m_ses->access_token); m_ses->auth_header = create_auth_header(m_ses->access_token);
_do_login(a.name, a.pass); _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{ rexy::string session::_request_access_token(const rexy::string_base& name, const rexy::string_base& pass, const rexy::string_base& loginurl)const{
raii::string postdata = json::_login_password(name, pass); rexy::string postdata = json::_login_password(name, pass);
raii::string reply = _post_curl(postdata, loginurl, raii::curl_llist{}); rexy::string reply = _post_curl(postdata, loginurl, raii::curl_llist{});
return reply; return reply;
} }
netreturn<raii::rjp_string> session::_get_userid(void){ netreturn<raii::rjp_string> session::_get_userid(void){
return _get_and_find(rest::session_urls::whoami(*m_ses), json::keys::auth::userid()); return _get_and_find(rest::session_urls::whoami(*m_ses), json::keys::auth::userid());
} }
netreturn<std::pair<raii::rjp_string,raii::rjp_string>> session::_get_new_access_token(const raii::string_base& name, const raii::string_base& pass, const raii::string_base& loginurl){ netreturn<std::pair<raii::rjp_string,raii::rjp_string>> session::_get_new_access_token(const rexy::string_base& name, const rexy::string_base& pass, const rexy::string_base& loginurl){
raii::string reply = _request_access_token(name, pass, loginurl); rexy::string reply = _request_access_token(name, pass, loginurl);
if(!reply) if(!reply)
return _create_netreturn(reply, http_status()); return _create_netreturn(reply, http_status());
raii::rjp_ptr root(rjp_parse(reply)); raii::rjp_ptr root(rjp_parse(reply));

10
src/matrix/sync_response.cpp
View File

@ -21,8 +21,8 @@
namespace matrix::sync{ namespace matrix::sync{
//Room event response //Room event response
raii::static_string room_event_response::roomid(void)const{ rexy::static_string room_event_response::roomid(void)const{
return raii::static_string(rjp_member_key(m_room)->value, rjp_member_key(m_room)->length); 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* room_event_response::_find_event_list(const char* mname)const{
RJP_value* res = rjp_search_member(m_room, mname); RJP_value* res = rjp_search_member(m_room, mname);
@ -50,7 +50,7 @@ namespace matrix::sync{
} }
//Sync response //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)){} m_root(rjp_parse(s)){}
client_response::client_response(RJP_value* root): client_response::client_response(RJP_value* root):
m_root(root){} m_root(root){}
@ -66,10 +66,10 @@ namespace matrix::sync{
device_list client_response::device_lists(void)const{ device_list client_response::device_lists(void)const{
return rjp_search_member(m_root.get(), "device_lists"); 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"); RJP_value* nb = rjp_search_member(m_root.get(), "next_batch");
if(!nb) return {}; 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)&&{ raii::rjp_string client_response::next_batch(void)&&{
return raii::rjp_string(rjp_search_member(m_root.get(), "next_batch")); return raii::rjp_string(rjp_search_member(m_root.get(), "next_batch"));

37
src/raii/binary.cpp
View File

@ -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 <http://www.gnu.org/licenses/>.
*/
#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];
}
}

8
src/raii/curler.cpp
View File

@ -62,19 +62,19 @@ namespace raii{
curler& curler::seturl(const char* s){ curler& curler::seturl(const char* s){
return setopt(CURLOPT_URL, 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()); return seturl(s.get());
} }
curler& curler::setuseragent(const char* s){ curler& curler::setuseragent(const char* s){
return setopt(CURLOPT_USERAGENT, 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()); return setuseragent(s.get());
} }
curler& curler::setuserpwd(const char* s){ curler& curler::setuserpwd(const char* s){
return setopt(CURLOPT_USERPWD, 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()); return setuserpwd(s.get());
} }
curler& curler::setpostdata(const char* s, curl_off_t len){ curler& curler::setpostdata(const char* s, curl_off_t len){
@ -82,7 +82,7 @@ namespace raii{
setopt(CURLOPT_POSTFIELDSIZE_LARGE, len); setopt(CURLOPT_POSTFIELDSIZE_LARGE, len);
return *this; return *this;
} }
curler& curler::setpostdata(const string_base& s){ curler& curler::setpostdata(const rexy::string_base& s){
setpostdata(s.get(), s.length()); setpostdata(s.get(), s.length());
return *this; return *this;
} }

112
src/raii/filerd.cpp
View File

@ -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 <http://www.gnu.org/licenses/>.
*/
#include "raii/filerd.hpp"
#include <cstdio> //fopen, fclose
#include <utility> //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<char*>(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<char*>(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());
}
}

49
src/raii/string_base.cpp
View File

@ -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 <http://www.gnu.org/licenses/>.
*/
#include "raii/string_base.hpp"
#include <utility> //exchange, swap
#include <cstdlib> //memcpy
#include <cstring> //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<char*>(c), strlen(c)){}
static_string& static_string::operator=(const char* c){
m_data = const_cast<char*>(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;
}
}

14
src/raii/util.cpp
View File

@ -16,7 +16,7 @@
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
#include "raii/string.hpp" #include <rexy/string.hpp>
namespace raii{ namespace raii{
@ -82,12 +82,12 @@ namespace raii{
return pos; 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()); size_t len = detail::_calc_escaped_len(str.get());
char* tmp = reinterpret_cast<char*>(string::allocator_type::allocate(len+1)); char* tmp = reinterpret_cast<char*>(rexy::string::allocator_type::allocate(len+1));
detail::_sanitize_json_copy(tmp, str); detail::_sanitize_json_copy(tmp, str);
tmp[len] = 0; 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) if(i == 0)
return raii::string("0"); return rexy::string("0");
int place = intlen(i); int place = intlen(i);
raii::string ret(place, place); rexy::string ret(place, place);
char* buf = ret.get(); char* buf = ret.get();
buf[place] = 0; buf[place] = 0;
while(i != 0){ while(i != 0){

35
src/test.cpp
View File

@ -19,11 +19,12 @@
//example of a client which responds to commands //example of a client which responds to commands
#include "matrix/matrix.hpp" #include "matrix/matrix.hpp"
#include "raii/string_base.hpp" #include <rexy/string_base.hpp>
#include "matrix/sync_response.hpp" #include "matrix/sync_response.hpp"
#include "raii/util.hpp" #include "raii/util.hpp"
#include "matrix/json_targets.hpp" #include "matrix/json_targets.hpp"
#include "matrix/events.hpp" #include "matrix/events.hpp"
#include <rexy/filerd.hpp>
#include <atomic> #include <atomic>
#include <thread> #include <thread>
@ -32,7 +33,7 @@
#include <cctype> #include <cctype>
matrix::auth_data read_auth_file(const char* filename){ matrix::auth_data read_auth_file(const char* filename){
raii::filerd fp(filename, "r"); rexy::filerd fp(filename, "r");
if(!fp){ if(!fp){
return {}; return {};
} }
@ -61,7 +62,7 @@ void write_to_auth_file(const char* filename, const matrix::auth_data& auth){
raii::rjp_string output; raii::rjp_string output;
output.reset(rjp_to_json(root.get(), RJP_FORMAT_NONE)); output.reset(rjp_to_json(root.get(), RJP_FORMAT_NONE));
raii::filerd fp(filename, "w"); rexy::filerd fp(filename, "w");
if(!fp) if(!fp)
return; return;
fp.write(output); fp.write(output);
@ -85,7 +86,7 @@ matrix::session login_to_homeserver(void){
} }
struct command{ 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&); 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){ void do_gaben(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event& event){
if(event.body().length() > 6){ if(event.body().length() > 6){
raii::static_string args = event.body().get() + 7; rexy::static_string args = event.body().get() + 7;
room.send_message(raii::string(args + " can suck my ass"_ss)); room.send_message(rexy::string(args + " can suck my ass"_ss));
}else{ }else{
room.send_notice("can suck my ass"_ss); 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); 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&){ 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); room.send_custom_event(str, "m.room.message"_ss);
} }
raii::string get_command_output(const raii::string_base& command){ rexy::string get_command_output(const rexy::string_base& command){
raii::string result; rexy::string result;
FILE* pipe = popen(command.get(), "r"); FILE* pipe = popen(command.get(), "r");
if(!pipe) if(!pipe)
return {}; 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){ 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); 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 state = 0;
int diecount = 1; int diecount = 1;
int sidecount = 100; 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){ void do_roll(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event& event){
int rollval; int rollval;
if(event.body().length() > 5){ 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; return;
}else{ }else{
if(roll_func(""_ss, rollval)) 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&){ 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" "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" "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" "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&){ void do_sauce(const matrix::client& client, const matrix::roomcxn& room, const matrix::sync::room_message_event&){
matrix::file_details fd; matrix::file_details fd;
fd.name = "src/test.cpp"_ss; fd.name = "src/test.cpp"_ss;
raii::filerd fp(fd.name); rexy::filerd fp(fd.name);
if(!fp){ if(!fp){
printf("fopen error\n"); printf("fopen error\n");
return; 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){ rexy::string get_showinfo(const rexy::string_base& file, const rexy::string_base& show){
raii::filerd fp(file); rexy::filerd fp(file);
if(!fp) if(!fp)
return {}; return {};
raii::string line; rexy::string line;
for(line = fp.readln();line.length();line = fp.readln()){ for(line = fp.readln();line.length();line = fp.readln()){
if(!strncmp(line, show, show.length()) && line[show.length()] == ':') if(!strncmp(line, show, show.length()) && line[show.length()] == ':')
return line; return line;