Start removing raii components into separate library. Strings, binary, and filerd were first to go
This commit is contained in:
rexy712
parent
22cadb1695
commit
41b976bd6a
@ -24,11 +24,11 @@
|
||||
namespace matrix{
|
||||
|
||||
struct auth_data{
|
||||
raii::string name;
|
||||
raii::string pass;
|
||||
raii::string homeserver;
|
||||
raii::string useragent;
|
||||
raii::string access_token;
|
||||
rexy::string name;
|
||||
rexy::string pass;
|
||||
rexy::string homeserver;
|
||||
rexy::string useragent;
|
||||
rexy::string access_token;
|
||||
|
||||
operator bool(void)const{
|
||||
return (name && pass && homeserver);
|
||||
|
||||
@ -19,9 +19,8 @@
|
||||
#ifndef MATRIX_CLIENT_HPP
|
||||
#define MATRIX_CLIENT_HPP
|
||||
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
#include "raii/rjp_string.hpp"
|
||||
#include "raii/filerd.hpp"
|
||||
#include "matrix/session_info.hpp"
|
||||
#include "matrix/upload_info.hpp"
|
||||
#include "matrix/connection.hpp"
|
||||
@ -58,22 +57,22 @@ namespace matrix{
|
||||
* Note name must be safe to be placed in a json string.
|
||||
* Returns: true if the operation was successful.
|
||||
*/
|
||||
netreturn<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.
|
||||
* Note url must be safe to be placed in a json string.
|
||||
* 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<raii::rjp_string> get_presence(const raii::string_base& userid);
|
||||
netreturn<void> set_presence(const rexy::string_base& status);
|
||||
netreturn<raii::rjp_string> get_presence(const rexy::string_base& userid);
|
||||
/*
|
||||
* Gets the display name of the logged in user from the homeserver.
|
||||
* Returns: the display name on success, an empty string on failure.
|
||||
*/
|
||||
netreturn<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.
|
||||
* Returns: the profile picture url on success, an empty string on failure.
|
||||
@ -83,7 +82,7 @@ namespace matrix{
|
||||
* Lookup a room id given a room alias.
|
||||
* Returns: the room id of the associated room on success, empty string on failure.
|
||||
*/
|
||||
netreturn<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.
|
||||
@ -95,7 +94,7 @@ namespace matrix{
|
||||
* Create a new room on the logged in user's homeserver. Assign an alias to the room.
|
||||
* Returns: the room id of the newly created room on success, an empty string on failure.
|
||||
*/
|
||||
netreturn<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.
|
||||
@ -103,8 +102,8 @@ namespace matrix{
|
||||
* access token, or homeserver after creating a roomcxn MUST be synchronized between threads.
|
||||
* Returns: a new matrix::roomcxn for the given roomid.
|
||||
*/
|
||||
roomcxn spawn_room(const raii::string_base& roomid)const;
|
||||
roomcxn spawn_room(raii::string&& roomid)const;
|
||||
roomcxn spawn_room(const rexy::string_base& roomid)const;
|
||||
roomcxn spawn_room(rexy::string&& roomid)const;
|
||||
|
||||
|
||||
//NOTE alias equivalents just give the uploaded file a name other than the filename.
|
||||
@ -139,9 +138,9 @@ namespace matrix{
|
||||
netreturn<void> create_thumbnail(uploaded_image& info)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>
|
||||
bool download_file(const raii::string_base& url, DLHandler&& dl){
|
||||
bool download_file(const rexy::string_base& url, DLHandler&& dl){
|
||||
_get_curl_setup(m_urls->file_download(*m_ses, url));
|
||||
m_curl.setwritefun(_download_dispatch<DLHandler>);
|
||||
m_curl.setwritedata(&dl);
|
||||
@ -150,8 +149,8 @@ namespace matrix{
|
||||
return true;
|
||||
}
|
||||
template<class DLHandler>
|
||||
bool download_file(const raii::string_base& server, const raii::string_base& media_id, DLHandler&& dl){
|
||||
raii::string url = "mxc://"_ss + server + "/"_ss + media_id;
|
||||
bool download_file(const rexy::string_base& server, const rexy::string_base& media_id, DLHandler&& dl){
|
||||
rexy::string url = "mxc://"_ss + server + "/"_ss + media_id;
|
||||
return download_file(url, std::forward<DLHandler>(dl));
|
||||
}
|
||||
|
||||
|
||||
@ -20,9 +20,9 @@
|
||||
#define MATRIX_CONNECTION_HPP
|
||||
|
||||
#include "raii/curler.hpp"
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
#include "raii/rjp_string.hpp"
|
||||
#include "raii/binary.hpp"
|
||||
#include <rexy/binary.hpp>
|
||||
#include "raii/rjp_ptr.hpp"
|
||||
#include "matrix/session_info.hpp"
|
||||
#include "matrix/netreturn.hpp"
|
||||
@ -59,7 +59,7 @@ namespace matrix{
|
||||
* NOT thread safe
|
||||
* Returns: the current useragent.
|
||||
*/
|
||||
const raii::string& useragent(void)const;
|
||||
const rexy::string& useragent(void)const;
|
||||
|
||||
/*
|
||||
* Returns: the http status code of the last operation performed.
|
||||
@ -73,30 +73,30 @@ namespace matrix{
|
||||
};
|
||||
static size_t _reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata);
|
||||
static size_t _binary_reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata);
|
||||
void _get_curl_setup(const raii::string_base& url)const;
|
||||
void _post_curl_setup(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header)const;
|
||||
void _get_curl_setup(const rexy::string_base& url)const;
|
||||
void _post_curl_setup(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header)const;
|
||||
static size_t _put_read_curl_callback(char* buffer, size_t size, size_t nmemb, void* userdata);
|
||||
void _put_curl_setup(put_data& data, const raii::string_base& url, const raii::curl_llist& header)const;
|
||||
void _put_curl_setup(put_data& data, const rexy::string_base& url, const raii::curl_llist& header)const;
|
||||
|
||||
protected:
|
||||
using binary_callback_fun = size_t(*)(char*, size_t, size_t, void*);
|
||||
using reply_callback_fun = size_t(*)(char*, size_t, size_t, void*);
|
||||
|
||||
void _set_curl_useragent(const raii::string_base& useragent);
|
||||
void _set_curl_useragent(const rexy::string_base& useragent);
|
||||
bool _perform_curl(void)const;
|
||||
raii::string _get_curl(const raii::string_base& url, reply_callback_fun fun = _reply_curl_callback)const;
|
||||
raii::binary _get_curl_binary(const raii::string_base& url, binary_callback_fun fun = _binary_reply_curl_callback)const;
|
||||
raii::string _post_curl(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, reply_callback_fun = _reply_curl_callback)const;
|
||||
raii::binary _post_curl_binary(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, binary_callback_fun = _binary_reply_curl_callback)const;
|
||||
raii::string _put_curl(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, reply_callback_fun = _reply_curl_callback)const;
|
||||
raii::binary _put_curl_binary(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, binary_callback_fun = _binary_reply_curl_callback)const;
|
||||
netreturn<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> _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> _get_and_find(const raii::string_base& url, const raii::string_base& search)const;
|
||||
raii::rjp_string _curl_reply_search(const raii::string_base& reply, const raii::string_base& search)const;
|
||||
raii::rjp_string _curl_reply_search(const raii::rjp_ptr& root, const raii::string_base& search)const;
|
||||
void _set_curl_defaults(const raii::string_base& useragent)const;
|
||||
static netreturn_base _create_netreturn(const raii::string_base& mxjson, int httpstatus);
|
||||
rexy::string _get_curl(const rexy::string_base& url, reply_callback_fun fun = _reply_curl_callback)const;
|
||||
rexy::binary _get_curl_binary(const rexy::string_base& url, binary_callback_fun fun = _binary_reply_curl_callback)const;
|
||||
rexy::string _post_curl(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, reply_callback_fun = _reply_curl_callback)const;
|
||||
rexy::binary _post_curl_binary(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, binary_callback_fun = _binary_reply_curl_callback)const;
|
||||
rexy::string _put_curl(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, reply_callback_fun = _reply_curl_callback)const;
|
||||
rexy::binary _put_curl_binary(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, binary_callback_fun = _binary_reply_curl_callback)const;
|
||||
netreturn<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 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 rexy::string_base& url, const rexy::string_base& search)const;
|
||||
raii::rjp_string _curl_reply_search(const rexy::string_base& reply, const rexy::string_base& search)const;
|
||||
raii::rjp_string _curl_reply_search(const raii::rjp_ptr& root, const rexy::string_base& search)const;
|
||||
void _set_curl_defaults(const rexy::string_base& useragent)const;
|
||||
static netreturn_base _create_netreturn(const rexy::string_base& mxjson, int httpstatus);
|
||||
static netreturn_base _create_netreturn(const raii::rjp_ptr& root, int httpstatus);
|
||||
};
|
||||
|
||||
|
||||
@ -20,7 +20,7 @@
|
||||
#define MATRIX_EVENT_HPP
|
||||
|
||||
#include "raii/rjp_ptr.hpp"
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/string_base.hpp>
|
||||
#include "raii/rjp_string.hpp"
|
||||
|
||||
namespace matrix::sync{
|
||||
@ -42,7 +42,7 @@ namespace matrix::sync{
|
||||
~event(void) = default;
|
||||
event& operator=(const event&);
|
||||
|
||||
raii::static_string type(void)const&;
|
||||
rexy::static_string type(void)const&;
|
||||
raii::rjp_string type(void)&&;
|
||||
const RJP_value* content(void)const;
|
||||
RJP_value* content(void);
|
||||
@ -57,16 +57,16 @@ namespace matrix::sync{
|
||||
class room_event_base
|
||||
{
|
||||
protected:
|
||||
raii::static_string m_roomid;
|
||||
rexy::static_string m_roomid;
|
||||
public:
|
||||
room_event_base(void) = default;
|
||||
room_event_base(const room_event_base&) = delete;
|
||||
constexpr room_event_base(room_event_base&&) = default;
|
||||
room_event_base& operator=(const room_event_base&) = default;
|
||||
|
||||
constexpr room_event_base(const raii::string_base& roomid):
|
||||
constexpr room_event_base(const rexy::string_base& roomid):
|
||||
m_roomid(roomid.get(), roomid.length()){}
|
||||
constexpr const raii::static_string& roomid(void)const{
|
||||
constexpr const rexy::static_string& roomid(void)const{
|
||||
return m_roomid;
|
||||
}
|
||||
};
|
||||
@ -84,22 +84,22 @@ namespace matrix::sync{
|
||||
int m_origin_server_ts;
|
||||
public:
|
||||
room_event(void) = default;
|
||||
room_event(RJP_value* ev, const raii::string_base& roomid);
|
||||
room_event(RJP_value* ev, const rexy::string_base& roomid);
|
||||
room_event(const room_event&) = delete; //TODO
|
||||
room_event(room_event&&)noexcept;
|
||||
room_event& operator=(const room_event&) = delete;
|
||||
room_event& operator=(room_event&&);
|
||||
|
||||
raii::static_string eventid(void)const&;
|
||||
rexy::static_string eventid(void)const&;
|
||||
raii::rjp_string eventid(void)&&;
|
||||
raii::static_string sender(void)const&;
|
||||
rexy::static_string sender(void)const&;
|
||||
raii::rjp_string sender(void)&&;
|
||||
int origin_server_ts(void)const;
|
||||
const RJP_value* extra(void)const;
|
||||
RJP_value* extra(void);
|
||||
|
||||
//only for m.room.redacts events
|
||||
raii::static_string redacts(void)const&;
|
||||
rexy::static_string redacts(void)const&;
|
||||
raii::rjp_string redacts(void)&&;
|
||||
};
|
||||
|
||||
@ -113,15 +113,15 @@ namespace matrix::sync{
|
||||
RJP_value* m_prev_content;
|
||||
public:
|
||||
room_state_event(void) = default;
|
||||
room_state_event(RJP_value* ev, const raii::string_base& roomid);
|
||||
room_state_event(RJP_value* ev, const rexy::string_base& roomid);
|
||||
room_state_event(const room_state_event&) = delete; //TODO
|
||||
room_state_event(room_state_event&&);
|
||||
|
||||
room_state_event& operator=(const room_state_event&) = delete;
|
||||
room_state_event& operator=(room_state_event&&);
|
||||
raii::static_string state_key(void)const&;
|
||||
rexy::static_string state_key(void)const&;
|
||||
raii::rjp_string state_key(void)&&;
|
||||
raii::static_string prev_content(void)const&;
|
||||
rexy::static_string prev_content(void)const&;
|
||||
raii::rjp_string prev_content(void)&&;
|
||||
};
|
||||
|
||||
@ -131,7 +131,7 @@ namespace matrix::sync{
|
||||
class room_ephemeral_event : public room_event_base, public event
|
||||
{
|
||||
public:
|
||||
room_ephemeral_event(RJP_value* ev, const raii::string_base& roomid);
|
||||
room_ephemeral_event(RJP_value* ev, const rexy::string_base& roomid);
|
||||
room_ephemeral_event(const room_ephemeral_event&) = delete; //TODO
|
||||
room_ephemeral_event(room_ephemeral_event&&) = default;
|
||||
};
|
||||
@ -144,15 +144,15 @@ namespace matrix::sync{
|
||||
RJP_value* m_body;
|
||||
RJP_value* m_type;
|
||||
public:
|
||||
room_message_event(RJP_value* ev, const raii::string_base& roomid);
|
||||
room_message_event(RJP_value* ev, const rexy::string_base& roomid);
|
||||
room_message_event(const room_message_event&) = delete;
|
||||
room_message_event(room_message_event&&);
|
||||
room_message_event(room_event&&)noexcept;
|
||||
|
||||
raii::static_string body(void)const&;
|
||||
rexy::static_string body(void)const&;
|
||||
raii::rjp_string body(void)&&;
|
||||
|
||||
raii::static_string msgtype(void)const&;
|
||||
rexy::static_string msgtype(void)const&;
|
||||
raii::rjp_string msgtype(void)&&;
|
||||
};
|
||||
|
||||
|
||||
@ -24,30 +24,30 @@
|
||||
//these functions should rarely change, so it will still build slowly
|
||||
//but will rarely need rebuilt
|
||||
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
#include "matrix/upload_info.hpp"
|
||||
|
||||
namespace matrix::json{
|
||||
raii::static_string _empty(void);
|
||||
rexy::static_string _empty(void);
|
||||
|
||||
raii::string _image_body(const uploaded_image& image);
|
||||
raii::string _video_body(const uploaded_video& video);
|
||||
raii::string _file_body(const uploaded_file& video);
|
||||
raii::string _audio_body(const uploaded_audio& audio);
|
||||
raii::string _message_body(const raii::string_base& text);
|
||||
raii::string _notice_body(const raii::string_base& msg);
|
||||
raii::string _login_password(const raii::string_base& userid, const raii::string_base& password);
|
||||
raii::string _change_psk_password(const raii::string_base& userid, const raii::string_base& newpass, const raii::string_base& oldpass, const raii::string_base& session);
|
||||
rexy::string _image_body(const uploaded_image& image);
|
||||
rexy::string _video_body(const uploaded_video& video);
|
||||
rexy::string _file_body(const uploaded_file& video);
|
||||
rexy::string _audio_body(const uploaded_audio& audio);
|
||||
rexy::string _message_body(const rexy::string_base& text);
|
||||
rexy::string _notice_body(const rexy::string_base& msg);
|
||||
rexy::string _login_password(const rexy::string_base& userid, const rexy::string_base& password);
|
||||
rexy::string _change_psk_password(const rexy::string_base& userid, const rexy::string_base& newpass, const rexy::string_base& oldpass, const rexy::string_base& session);
|
||||
|
||||
raii::string _displayname_set(const raii::string_base& newname);
|
||||
raii::string _avatar_set(const raii::string_base& mediaurl);
|
||||
raii::string _presence_set(const raii::string_base& status);
|
||||
raii::string _create_room(const raii::string_base& name, const raii::string_base& alias);
|
||||
raii::string _userid(const raii::string_base& id);
|
||||
raii::string _userid_reason(const raii::string_base& id, const raii::string_base& reason);
|
||||
raii::string _typing(bool active, int timeout);
|
||||
raii::string _redact(const raii::string_base& reason);
|
||||
raii::string _room_upgrade(int version);
|
||||
rexy::string _displayname_set(const rexy::string_base& newname);
|
||||
rexy::string _avatar_set(const rexy::string_base& mediaurl);
|
||||
rexy::string _presence_set(const rexy::string_base& status);
|
||||
rexy::string _create_room(const rexy::string_base& name, const rexy::string_base& alias);
|
||||
rexy::string _userid(const rexy::string_base& id);
|
||||
rexy::string _userid_reason(const rexy::string_base& id, const rexy::string_base& reason);
|
||||
rexy::string _typing(bool active, int timeout);
|
||||
rexy::string _redact(const rexy::string_base& reason);
|
||||
rexy::string _room_upgrade(int version);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -20,7 +20,7 @@
|
||||
#define MATRIX_ITERABLE_HPP
|
||||
|
||||
#include "matrix/events.hpp"
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/string_base.hpp>
|
||||
#include "raii/rjp_string.hpp"
|
||||
#include "raii/rjp_iterator.hpp"
|
||||
|
||||
@ -64,11 +64,11 @@ namespace matrix::sync{
|
||||
{
|
||||
protected:
|
||||
raii::rjp_array_iterator m_event;
|
||||
raii::static_string m_roomid;
|
||||
rexy::static_string m_roomid;
|
||||
public:
|
||||
constexpr room_event_iterator(void):
|
||||
m_event(nullptr), m_roomid(){}
|
||||
constexpr room_event_iterator(RJP_value* v, const raii::string_base& roomid):
|
||||
constexpr room_event_iterator(RJP_value* v, const rexy::string_base& roomid):
|
||||
m_event(v), m_roomid(roomid){}
|
||||
constexpr room_event_iterator(const room_event_iterator& i):
|
||||
m_event(i.m_event), m_roomid(i.m_roomid){}
|
||||
@ -94,7 +94,7 @@ namespace matrix::sync{
|
||||
constexpr T operator*(void){
|
||||
return T(*m_event, m_roomid);
|
||||
}
|
||||
constexpr const raii::static_string& roomid(void)const{
|
||||
constexpr const rexy::static_string& roomid(void)const{
|
||||
return m_roomid;
|
||||
}
|
||||
};
|
||||
@ -137,7 +137,7 @@ namespace matrix::sync{
|
||||
iterator m_event;
|
||||
public:
|
||||
constexpr iterable_room_event_base(void) = default;
|
||||
constexpr iterable_room_event_base(RJP_value* ev, const raii::string_base& roomid):
|
||||
constexpr iterable_room_event_base(RJP_value* ev, const rexy::string_base& roomid):
|
||||
m_event(ev, roomid){}
|
||||
constexpr iterable_room_event_base(const iterable_room_event_base& i):
|
||||
m_event(i.m_event){}
|
||||
@ -189,10 +189,10 @@ namespace matrix::sync{
|
||||
raii::rjp_ptr m_root;
|
||||
public:
|
||||
constexpr roomcxn_event_list_base(void) = default;
|
||||
roomcxn_event_list_base(raii::rjp_ptr& root, RJP_value* event, const raii::string_base& roomid);
|
||||
raii::static_string start_token(void)const&;
|
||||
roomcxn_event_list_base(raii::rjp_ptr& root, RJP_value* event, const rexy::string_base& roomid);
|
||||
rexy::static_string start_token(void)const&;
|
||||
raii::rjp_string start_token(void)&&;
|
||||
raii::static_string end_token(void)const&;
|
||||
rexy::static_string end_token(void)const&;
|
||||
raii::rjp_string end_token(void)&&;
|
||||
};
|
||||
extern template class roomcxn_event_list_base<room_state_event>;
|
||||
|
||||
@ -1,97 +1,97 @@
|
||||
#ifndef MATRIX_JSON_TARGETS_HPP
|
||||
#define MATRIX_JSON_TARGETS_HPP
|
||||
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/string_base.hpp>
|
||||
|
||||
namespace matrix::json{
|
||||
|
||||
constexpr raii::static_string True(void){return "true"_ss;}
|
||||
constexpr raii::static_string False(void){return "false"_ss;}
|
||||
constexpr raii::static_string reason(void){return "reason"_ss;}
|
||||
constexpr rexy::static_string True(void){return "true"_ss;}
|
||||
constexpr rexy::static_string False(void){return "false"_ss;}
|
||||
constexpr rexy::static_string reason(void){return "reason"_ss;}
|
||||
|
||||
namespace keys{
|
||||
constexpr raii::static_string error(void){return "error"_ss;}
|
||||
constexpr raii::static_string errcode(void){return "errcode"_ss;}
|
||||
constexpr raii::static_string retry_after(void){return "retry_after_ms"_ss;}
|
||||
constexpr raii::static_string joined(void){return "joined"_ss;}
|
||||
constexpr raii::static_string chunk(void){return "chunk"_ss;}
|
||||
constexpr raii::static_string newversion(void){return "new_version"_ss;}
|
||||
constexpr raii::static_string presence(void){return "presence"_ss;}
|
||||
constexpr raii::static_string displayname(void){return "displayname"_ss;}
|
||||
constexpr raii::static_string avatarurl(void){return "avatar_url"_ss;}
|
||||
constexpr raii::static_string joinedrooms(void){return "joined_rooms"_ss;}
|
||||
constexpr raii::static_string contenturi(void){return "content_uri"_ss;}
|
||||
constexpr raii::static_string name(void){return "name"_ss;}
|
||||
constexpr raii::static_string roomaliasname(void){return "room_alias_name"_ss;}
|
||||
constexpr raii::static_string typing(void){return "typing"_ss;}
|
||||
constexpr raii::static_string timeout(void){return "timeout"_ss;}
|
||||
constexpr raii::static_string session(void){return "session"_ss;}
|
||||
constexpr rexy::static_string error(void){return "error"_ss;}
|
||||
constexpr rexy::static_string errcode(void){return "errcode"_ss;}
|
||||
constexpr rexy::static_string retry_after(void){return "retry_after_ms"_ss;}
|
||||
constexpr rexy::static_string joined(void){return "joined"_ss;}
|
||||
constexpr rexy::static_string chunk(void){return "chunk"_ss;}
|
||||
constexpr rexy::static_string newversion(void){return "new_version"_ss;}
|
||||
constexpr rexy::static_string presence(void){return "presence"_ss;}
|
||||
constexpr rexy::static_string displayname(void){return "displayname"_ss;}
|
||||
constexpr rexy::static_string avatarurl(void){return "avatar_url"_ss;}
|
||||
constexpr rexy::static_string joinedrooms(void){return "joined_rooms"_ss;}
|
||||
constexpr rexy::static_string contenturi(void){return "content_uri"_ss;}
|
||||
constexpr rexy::static_string name(void){return "name"_ss;}
|
||||
constexpr rexy::static_string roomaliasname(void){return "room_alias_name"_ss;}
|
||||
constexpr rexy::static_string typing(void){return "typing"_ss;}
|
||||
constexpr rexy::static_string timeout(void){return "timeout"_ss;}
|
||||
constexpr rexy::static_string session(void){return "session"_ss;}
|
||||
|
||||
namespace event{
|
||||
constexpr raii::static_string type(void){return "type"_ss;}
|
||||
constexpr raii::static_string content(void){return "content"_ss;}
|
||||
constexpr raii::static_string eventid(void){return "event_id"_ss;}
|
||||
constexpr raii::static_string sender(void){return "sender"_ss;}
|
||||
constexpr raii::static_string origin_server_ts(void){return "origin_server_ts"_ss;}
|
||||
constexpr raii::static_string roomid(void){return "room_id"_ss;}
|
||||
constexpr raii::static_string extra(void){return "unsigned"_ss;}
|
||||
constexpr raii::static_string state_key(void){return "state_key"_ss;}
|
||||
constexpr raii::static_string prev_content(void){return "prev_content"_ss;}
|
||||
constexpr raii::static_string redacts(void){return "redacts"_ss;}
|
||||
constexpr rexy::static_string type(void){return "type"_ss;}
|
||||
constexpr rexy::static_string content(void){return "content"_ss;}
|
||||
constexpr rexy::static_string eventid(void){return "event_id"_ss;}
|
||||
constexpr rexy::static_string sender(void){return "sender"_ss;}
|
||||
constexpr rexy::static_string origin_server_ts(void){return "origin_server_ts"_ss;}
|
||||
constexpr rexy::static_string roomid(void){return "room_id"_ss;}
|
||||
constexpr rexy::static_string extra(void){return "unsigned"_ss;}
|
||||
constexpr rexy::static_string state_key(void){return "state_key"_ss;}
|
||||
constexpr rexy::static_string prev_content(void){return "prev_content"_ss;}
|
||||
constexpr rexy::static_string redacts(void){return "redacts"_ss;}
|
||||
|
||||
namespace contentbody{
|
||||
constexpr raii::static_string body(void){return "body"_ss;}
|
||||
constexpr raii::static_string info(void){return "info"_ss;}
|
||||
constexpr rexy::static_string body(void){return "body"_ss;}
|
||||
constexpr rexy::static_string info(void){return "info"_ss;}
|
||||
namespace infobody{
|
||||
constexpr raii::static_string height(void){return "h"_ss;}
|
||||
constexpr raii::static_string width(void){return "w"_ss;}
|
||||
constexpr raii::static_string mimetype(void){return "mimetype"_ss;}
|
||||
constexpr raii::static_string size(void){return "size"_ss;}
|
||||
constexpr raii::static_string thumbinfo(void){return "thumbnail_info"_ss;}
|
||||
constexpr rexy::static_string height(void){return "h"_ss;}
|
||||
constexpr rexy::static_string width(void){return "w"_ss;}
|
||||
constexpr rexy::static_string mimetype(void){return "mimetype"_ss;}
|
||||
constexpr rexy::static_string size(void){return "size"_ss;}
|
||||
constexpr rexy::static_string thumbinfo(void){return "thumbnail_info"_ss;}
|
||||
namespace thumbnail{
|
||||
constexpr raii::static_string height(void){return infobody::height();}
|
||||
constexpr raii::static_string width(void){return infobody::width();}
|
||||
constexpr raii::static_string mimetype(void){return infobody::mimetype();}
|
||||
constexpr raii::static_string size(void){return infobody::size();}
|
||||
constexpr rexy::static_string height(void){return infobody::height();}
|
||||
constexpr rexy::static_string width(void){return infobody::width();}
|
||||
constexpr rexy::static_string mimetype(void){return infobody::mimetype();}
|
||||
constexpr rexy::static_string size(void){return infobody::size();}
|
||||
}
|
||||
constexpr raii::static_string thumburl(void){return "thumbnail_url"_ss;}
|
||||
constexpr rexy::static_string thumburl(void){return "thumbnail_url"_ss;}
|
||||
}
|
||||
constexpr raii::static_string msgtype(void){return "msgtype"_ss;}
|
||||
constexpr raii::static_string url(void){return "url"_ss;}
|
||||
constexpr rexy::static_string msgtype(void){return "msgtype"_ss;}
|
||||
constexpr rexy::static_string url(void){return "url"_ss;}
|
||||
}
|
||||
}
|
||||
|
||||
namespace auth{
|
||||
constexpr raii::static_string type(void){return event::type();}
|
||||
constexpr raii::static_string medium(void){return "medium"_ss;}
|
||||
constexpr raii::static_string address(void){return "address"_ss;}
|
||||
constexpr raii::static_string identifier(void){return "identifier"_ss;}
|
||||
constexpr raii::static_string user(void){return "user"_ss;}
|
||||
constexpr raii::static_string password(void){return "password"_ss;}
|
||||
constexpr raii::static_string token(void){return "token"_ss;}
|
||||
constexpr raii::static_string device_id(void){return "device_id"_ss;}
|
||||
constexpr raii::static_string initial_device_display_name(void){return "initial_device_display_name"_ss;}
|
||||
constexpr raii::static_string newpassword(void){return "new_password"_ss;}
|
||||
constexpr raii::static_string auth(void){return "auth"_ss;}
|
||||
constexpr raii::static_string userid(void){return "user_id"_ss;}
|
||||
constexpr raii::static_string accesstoken(void){return "access_token"_ss;}
|
||||
constexpr raii::static_string home_server(void){return "home_server"_ss;}
|
||||
constexpr raii::static_string well_known(void){return "well_known"_ss;}
|
||||
constexpr raii::static_string base_url(void){return "base_url"_ss;}
|
||||
constexpr raii::static_string inhibit_login(void){return "inhibit_login"_ss;}
|
||||
constexpr rexy::static_string type(void){return event::type();}
|
||||
constexpr rexy::static_string medium(void){return "medium"_ss;}
|
||||
constexpr rexy::static_string address(void){return "address"_ss;}
|
||||
constexpr rexy::static_string identifier(void){return "identifier"_ss;}
|
||||
constexpr rexy::static_string user(void){return "user"_ss;}
|
||||
constexpr rexy::static_string password(void){return "password"_ss;}
|
||||
constexpr rexy::static_string token(void){return "token"_ss;}
|
||||
constexpr rexy::static_string device_id(void){return "device_id"_ss;}
|
||||
constexpr rexy::static_string initial_device_display_name(void){return "initial_device_display_name"_ss;}
|
||||
constexpr rexy::static_string newpassword(void){return "new_password"_ss;}
|
||||
constexpr rexy::static_string auth(void){return "auth"_ss;}
|
||||
constexpr rexy::static_string userid(void){return "user_id"_ss;}
|
||||
constexpr rexy::static_string accesstoken(void){return "access_token"_ss;}
|
||||
constexpr rexy::static_string home_server(void){return "home_server"_ss;}
|
||||
constexpr rexy::static_string well_known(void){return "well_known"_ss;}
|
||||
constexpr rexy::static_string base_url(void){return "base_url"_ss;}
|
||||
constexpr rexy::static_string inhibit_login(void){return "inhibit_login"_ss;}
|
||||
namespace authbody{
|
||||
constexpr raii::static_string type(void){return auth::type();}
|
||||
constexpr raii::static_string session(void){return "session"_ss;}
|
||||
constexpr raii::static_string user(void){return auth::user();}
|
||||
constexpr raii::static_string password(void){return auth::password();}
|
||||
constexpr rexy::static_string type(void){return auth::type();}
|
||||
constexpr rexy::static_string session(void){return "session"_ss;}
|
||||
constexpr rexy::static_string user(void){return auth::user();}
|
||||
constexpr rexy::static_string password(void){return auth::password();}
|
||||
}
|
||||
namespace identifierbody{
|
||||
constexpr raii::static_string type(void){return auth::type();}
|
||||
constexpr raii::static_string medium(void){return auth::medium();}
|
||||
constexpr raii::static_string address(void){return auth::address();}
|
||||
constexpr raii::static_string session(void){return auth::authbody::session();}
|
||||
constexpr raii::static_string user(void){return auth::authbody::user();}
|
||||
constexpr raii::static_string password(void){return auth::password();}
|
||||
constexpr rexy::static_string type(void){return auth::type();}
|
||||
constexpr rexy::static_string medium(void){return auth::medium();}
|
||||
constexpr rexy::static_string address(void){return auth::address();}
|
||||
constexpr rexy::static_string session(void){return auth::authbody::session();}
|
||||
constexpr rexy::static_string user(void){return auth::authbody::user();}
|
||||
constexpr rexy::static_string password(void){return auth::password();}
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -99,101 +99,101 @@ namespace matrix::json{
|
||||
|
||||
}
|
||||
namespace events{
|
||||
constexpr raii::static_string homeserver(void){return "m.homeserver"_ss;}
|
||||
constexpr raii::static_string identity_server(void){return "m.identity_server"_ss;}
|
||||
constexpr raii::static_string presence(void){return "m.presence"_ss;}
|
||||
constexpr raii::static_string direct(void){return "m.direct"_ss;}
|
||||
constexpr raii::static_string ignored_user_list(void){return "m.ignored_user_list"_ss;}
|
||||
constexpr raii::static_string joined_member_count(void){return "m.joined_member_count"_ss;}
|
||||
constexpr raii::static_string invited_member_count(void){return "m.invited_member_count"_ss;}
|
||||
constexpr rexy::static_string homeserver(void){return "m.homeserver"_ss;}
|
||||
constexpr rexy::static_string identity_server(void){return "m.identity_server"_ss;}
|
||||
constexpr rexy::static_string presence(void){return "m.presence"_ss;}
|
||||
constexpr rexy::static_string direct(void){return "m.direct"_ss;}
|
||||
constexpr rexy::static_string ignored_user_list(void){return "m.ignored_user_list"_ss;}
|
||||
constexpr rexy::static_string joined_member_count(void){return "m.joined_member_count"_ss;}
|
||||
constexpr rexy::static_string invited_member_count(void){return "m.invited_member_count"_ss;}
|
||||
|
||||
namespace key{
|
||||
constexpr raii::static_string verification_request(void){return "m.key.verification.request"_ss;}
|
||||
constexpr raii::static_string verification_start(void){return "m.key.verification.start"_ss;}
|
||||
constexpr raii::static_string verification_cancel(void){return "m.key.verification.cancel"_ss;}
|
||||
constexpr raii::static_string verification_accept(void){return "m.key.verification.accept"_ss;}
|
||||
constexpr raii::static_string verification_key(void){return "m.key.verification.key"_ss;}
|
||||
constexpr raii::static_string verification_mac(void){return "m.key.verification.mac"_ss;}
|
||||
constexpr rexy::static_string verification_request(void){return "m.key.verification.request"_ss;}
|
||||
constexpr rexy::static_string verification_start(void){return "m.key.verification.start"_ss;}
|
||||
constexpr rexy::static_string verification_cancel(void){return "m.key.verification.cancel"_ss;}
|
||||
constexpr rexy::static_string verification_accept(void){return "m.key.verification.accept"_ss;}
|
||||
constexpr rexy::static_string verification_key(void){return "m.key.verification.key"_ss;}
|
||||
constexpr rexy::static_string verification_mac(void){return "m.key.verification.mac"_ss;}
|
||||
}
|
||||
namespace login{
|
||||
constexpr raii::static_string password(void){return "m.login.password"_ss;}
|
||||
constexpr raii::static_string recaptcha(void){return "m.login.recaptcha"_ss;}
|
||||
constexpr raii::static_string oauth2(void){return "m.login.oauth2"_ss;}
|
||||
constexpr raii::static_string email(void){return "m.login.email.identity"_ss;}
|
||||
constexpr raii::static_string msisdn(void){return "m.login.msisdn"_ss;}
|
||||
constexpr raii::static_string token(void){return "m.login.token"_ss;}
|
||||
constexpr raii::static_string dummy(void){return "m.login.dummy"_ss;}
|
||||
constexpr rexy::static_string password(void){return "m.login.password"_ss;}
|
||||
constexpr rexy::static_string recaptcha(void){return "m.login.recaptcha"_ss;}
|
||||
constexpr rexy::static_string oauth2(void){return "m.login.oauth2"_ss;}
|
||||
constexpr rexy::static_string email(void){return "m.login.email.identity"_ss;}
|
||||
constexpr rexy::static_string msisdn(void){return "m.login.msisdn"_ss;}
|
||||
constexpr rexy::static_string token(void){return "m.login.token"_ss;}
|
||||
constexpr rexy::static_string dummy(void){return "m.login.dummy"_ss;}
|
||||
}
|
||||
namespace id{
|
||||
constexpr raii::static_string user(void){return "m.id.user"_ss;}
|
||||
constexpr raii::static_string thirdparty(void){return "m.id.thirdparty"_ss;}
|
||||
constexpr raii::static_string phone(void){return "m.id.phone"_ss;}
|
||||
constexpr rexy::static_string user(void){return "m.id.user"_ss;}
|
||||
constexpr rexy::static_string thirdparty(void){return "m.id.thirdparty"_ss;}
|
||||
constexpr rexy::static_string phone(void){return "m.id.phone"_ss;}
|
||||
}
|
||||
namespace rule{
|
||||
constexpr raii::static_string rules(void){return "m.push_rules"_ss;}
|
||||
constexpr raii::static_string master(void){return ".m.rule.master"_ss;}
|
||||
constexpr raii::static_string suppress_notices(void){return ".m.rule.suppress_notices"_ss;}
|
||||
constexpr raii::static_string invite_for_me(void){return ".m.rule.invite_for_me"_ss;}
|
||||
constexpr raii::static_string member_event(void){return ".m.rule.member_event"_ss;}
|
||||
constexpr raii::static_string contains_displayname(void){return ".m.rule.contains_display_name"_ss;}
|
||||
constexpr raii::static_string tombstone(void){return ".m.rule.tombstone"_ss;}
|
||||
constexpr raii::static_string roomnotif(void){return ".m.rule.roomnotif"_ss;}
|
||||
constexpr raii::static_string contains_username(void){return ".m.rule.contains_user_name"_ss;}
|
||||
constexpr raii::static_string call(void){return ".m.rule.call"_ss;}
|
||||
constexpr raii::static_string encrypted_one_to_one(void){return ".m.rule.encrypted_room_one_to_one"_ss;}
|
||||
constexpr raii::static_string message(void){return ".m.rule.message"_ss;}
|
||||
constexpr raii::static_string encrypted(void){return ".m.rule.encrypted"_ss;}
|
||||
constexpr rexy::static_string rules(void){return "m.push_rules"_ss;}
|
||||
constexpr rexy::static_string master(void){return ".m.rule.master"_ss;}
|
||||
constexpr rexy::static_string suppress_notices(void){return ".m.rule.suppress_notices"_ss;}
|
||||
constexpr rexy::static_string invite_for_me(void){return ".m.rule.invite_for_me"_ss;}
|
||||
constexpr rexy::static_string member_event(void){return ".m.rule.member_event"_ss;}
|
||||
constexpr rexy::static_string contains_displayname(void){return ".m.rule.contains_display_name"_ss;}
|
||||
constexpr rexy::static_string tombstone(void){return ".m.rule.tombstone"_ss;}
|
||||
constexpr rexy::static_string roomnotif(void){return ".m.rule.roomnotif"_ss;}
|
||||
constexpr rexy::static_string contains_username(void){return ".m.rule.contains_user_name"_ss;}
|
||||
constexpr rexy::static_string call(void){return ".m.rule.call"_ss;}
|
||||
constexpr rexy::static_string encrypted_one_to_one(void){return ".m.rule.encrypted_room_one_to_one"_ss;}
|
||||
constexpr rexy::static_string message(void){return ".m.rule.message"_ss;}
|
||||
constexpr rexy::static_string encrypted(void){return ".m.rule.encrypted"_ss;}
|
||||
}
|
||||
namespace e2e{
|
||||
constexpr raii::static_string curve_aes_sha2(void){return "m.olm.v1.curve25519-aes-sha2"_ss;}
|
||||
constexpr raii::static_string aes_sha2(void){return "m.megolm.v1.aes-sha2"_ss;}
|
||||
constexpr raii::static_string encryption(void){return "m.room.encryption"_ss;}
|
||||
constexpr raii::static_string key(void){return "m.room_key"_ss;}
|
||||
constexpr raii::static_string key_request(void){return "m.room_key_request"_ss;}
|
||||
constexpr raii::static_string forwarded_key(void){return "m.forwarded_room_key"_ss;}
|
||||
constexpr raii::static_string dummy(void){return "m.dummy"_ss;}
|
||||
constexpr rexy::static_string curve_aes_sha2(void){return "m.olm.v1.curve25519-aes-sha2"_ss;}
|
||||
constexpr rexy::static_string aes_sha2(void){return "m.megolm.v1.aes-sha2"_ss;}
|
||||
constexpr rexy::static_string encryption(void){return "m.room.encryption"_ss;}
|
||||
constexpr rexy::static_string key(void){return "m.room_key"_ss;}
|
||||
constexpr rexy::static_string key_request(void){return "m.room_key_request"_ss;}
|
||||
constexpr rexy::static_string forwarded_key(void){return "m.forwarded_room_key"_ss;}
|
||||
constexpr rexy::static_string dummy(void){return "m.dummy"_ss;}
|
||||
}
|
||||
namespace room{
|
||||
constexpr raii::static_string aliases(void){return "m.room.aliases"_ss;}
|
||||
constexpr raii::static_string canonical_alias(void){return "m.room.canonical_alias"_ss;}
|
||||
constexpr raii::static_string create(void){return "m.room.create"_ss;}
|
||||
constexpr raii::static_string join_rules(void){return "m.room.join_rules"_ss;}
|
||||
constexpr raii::static_string member(void){return "m.room.member"_ss;}
|
||||
constexpr raii::static_string power_levels(void){return "m.room.power_levels"_ss;}
|
||||
constexpr raii::static_string redaction(void){return "m.room.redaction"_ss;}
|
||||
constexpr raii::static_string heroes(void){return "m.heroes"_ss;}
|
||||
constexpr raii::static_string message(void){return "m.room.message"_ss;}
|
||||
constexpr raii::static_string sticker(void){return "m.sticker"_ss;}
|
||||
[[deprecated]] constexpr raii::static_string message_feedback(void){return "m.room.message.feedback"_ss;}
|
||||
constexpr raii::static_string name(void){return "m.room.name"_ss;}
|
||||
constexpr raii::static_string topic(void){return "m.room.topic"_ss;}
|
||||
constexpr raii::static_string avatar(void){return "m.room.avatar"_ss;}
|
||||
constexpr raii::static_string pinned_events(void){return "m.room.pinned_events"_ss;}
|
||||
constexpr raii::static_string typing(void){return "m.typing"_ss;}
|
||||
constexpr raii::static_string receipt(void){return "m.receipt"_ss;}
|
||||
constexpr raii::static_string fully_read(void){return "m.fully_read"_ss;}
|
||||
constexpr raii::static_string history_visibility(void){return "m.room.history_visibility"_ss;}
|
||||
constexpr raii::static_string third_party_invite(void){return "m.room.third_party_invite"_ss;}
|
||||
constexpr raii::static_string guest_access(void){return "m.room.guest_access"_ss;}
|
||||
constexpr raii::static_string tag(void){return "m.tag"_ss;}
|
||||
constexpr raii::static_string server_acl(void){return "m.room.server_acl"_ss;}
|
||||
constexpr rexy::static_string aliases(void){return "m.room.aliases"_ss;}
|
||||
constexpr rexy::static_string canonical_alias(void){return "m.room.canonical_alias"_ss;}
|
||||
constexpr rexy::static_string create(void){return "m.room.create"_ss;}
|
||||
constexpr rexy::static_string join_rules(void){return "m.room.join_rules"_ss;}
|
||||
constexpr rexy::static_string member(void){return "m.room.member"_ss;}
|
||||
constexpr rexy::static_string power_levels(void){return "m.room.power_levels"_ss;}
|
||||
constexpr rexy::static_string redaction(void){return "m.room.redaction"_ss;}
|
||||
constexpr rexy::static_string heroes(void){return "m.heroes"_ss;}
|
||||
constexpr rexy::static_string message(void){return "m.room.message"_ss;}
|
||||
constexpr rexy::static_string sticker(void){return "m.sticker"_ss;}
|
||||
[[deprecated]] constexpr rexy::static_string message_feedback(void){return "m.room.message.feedback"_ss;}
|
||||
constexpr rexy::static_string name(void){return "m.room.name"_ss;}
|
||||
constexpr rexy::static_string topic(void){return "m.room.topic"_ss;}
|
||||
constexpr rexy::static_string avatar(void){return "m.room.avatar"_ss;}
|
||||
constexpr rexy::static_string pinned_events(void){return "m.room.pinned_events"_ss;}
|
||||
constexpr rexy::static_string typing(void){return "m.typing"_ss;}
|
||||
constexpr rexy::static_string receipt(void){return "m.receipt"_ss;}
|
||||
constexpr rexy::static_string fully_read(void){return "m.fully_read"_ss;}
|
||||
constexpr rexy::static_string history_visibility(void){return "m.room.history_visibility"_ss;}
|
||||
constexpr rexy::static_string third_party_invite(void){return "m.room.third_party_invite"_ss;}
|
||||
constexpr rexy::static_string guest_access(void){return "m.room.guest_access"_ss;}
|
||||
constexpr rexy::static_string tag(void){return "m.tag"_ss;}
|
||||
constexpr rexy::static_string server_acl(void){return "m.room.server_acl"_ss;}
|
||||
}
|
||||
namespace msgtype{
|
||||
constexpr raii::static_string text(void){return "m.text"_ss;}
|
||||
constexpr raii::static_string emote(void){return "m.emote"_ss;}
|
||||
constexpr raii::static_string notice(void){return "m.notice"_ss;}
|
||||
constexpr raii::static_string image(void){return "m.image"_ss;}
|
||||
constexpr raii::static_string file(void){return "m.file"_ss;}
|
||||
constexpr raii::static_string audio(void){return "m.audio"_ss;}
|
||||
constexpr raii::static_string location(void){return "m.location"_ss;}
|
||||
constexpr raii::static_string video(void){return "m.video"_ss;}
|
||||
constexpr raii::static_string server_notice(void){return "m.server_notice"_ss;}
|
||||
constexpr rexy::static_string text(void){return "m.text"_ss;}
|
||||
constexpr rexy::static_string emote(void){return "m.emote"_ss;}
|
||||
constexpr rexy::static_string notice(void){return "m.notice"_ss;}
|
||||
constexpr rexy::static_string image(void){return "m.image"_ss;}
|
||||
constexpr rexy::static_string file(void){return "m.file"_ss;}
|
||||
constexpr rexy::static_string audio(void){return "m.audio"_ss;}
|
||||
constexpr rexy::static_string location(void){return "m.location"_ss;}
|
||||
constexpr rexy::static_string video(void){return "m.video"_ss;}
|
||||
constexpr rexy::static_string server_notice(void){return "m.server_notice"_ss;}
|
||||
}
|
||||
namespace call{
|
||||
constexpr raii::static_string invite(void){return "m.call.invite"_ss;}
|
||||
constexpr raii::static_string candidates(void){return "m.call.candidates"_ss;}
|
||||
constexpr raii::static_string answer(void){return "m.call.answer"_ss;}
|
||||
constexpr raii::static_string hangup(void){return "m.call.hangup"_ss;}
|
||||
constexpr rexy::static_string invite(void){return "m.call.invite"_ss;}
|
||||
constexpr rexy::static_string candidates(void){return "m.call.candidates"_ss;}
|
||||
constexpr rexy::static_string answer(void){return "m.call.answer"_ss;}
|
||||
constexpr rexy::static_string hangup(void){return "m.call.hangup"_ss;}
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
@ -20,18 +20,18 @@
|
||||
#define MATRIX_REST_CLIENT_URL_LIST_HPP
|
||||
|
||||
#include "matrix/session_info.hpp"
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
#include "matrix/rest/urls_common.hpp"
|
||||
|
||||
namespace matrix::rest{
|
||||
class client_url_list
|
||||
{
|
||||
private:
|
||||
raii::string m_create_room;
|
||||
raii::string m_file_upload;
|
||||
raii::string m_room_list;
|
||||
raii::string m_alias_lookup;
|
||||
raii::string m_profile_picture;
|
||||
rexy::string m_create_room;
|
||||
rexy::string m_file_upload;
|
||||
rexy::string m_room_list;
|
||||
rexy::string m_alias_lookup;
|
||||
rexy::string m_profile_picture;
|
||||
|
||||
public:
|
||||
client_url_list(void) = default;
|
||||
@ -41,22 +41,22 @@ namespace matrix::rest{
|
||||
client_url_list& operator=(const client_url_list&) = default;
|
||||
client_url_list& operator=(client_url_list&&) = default;
|
||||
|
||||
const raii::string& create_room(void)const;
|
||||
const raii::string& file_upload(void)const;
|
||||
const raii::string& room_list(void)const;
|
||||
const raii::string& alias_lookup(void)const;
|
||||
const raii::string& profile_picture(void)const;
|
||||
raii::string displayname(const session_info& session, const raii::string_base& userid)const;
|
||||
raii::string file_download(const session_info& session, const raii::string_base& mediaid);
|
||||
raii::string file_thumbnail(const session_info& session, const raii::string_base& fileurl, int width, int height, const raii::string_base& method)const;
|
||||
raii::string presence(const session_info& session, const raii::string_base& userid)const;
|
||||
raii::string sync(const session_info& session, const raii::rjp_string& batch, const raii::string& timeout);
|
||||
const rexy::string& create_room(void)const;
|
||||
const rexy::string& file_upload(void)const;
|
||||
const rexy::string& room_list(void)const;
|
||||
const rexy::string& alias_lookup(void)const;
|
||||
const rexy::string& profile_picture(void)const;
|
||||
rexy::string displayname(const session_info& session, const rexy::string_base& userid)const;
|
||||
rexy::string file_download(const session_info& session, const rexy::string_base& mediaid);
|
||||
rexy::string file_thumbnail(const session_info& session, const rexy::string_base& fileurl, int width, int height, const rexy::string_base& method)const;
|
||||
rexy::string presence(const session_info& session, const rexy::string_base& userid)const;
|
||||
rexy::string sync(const session_info& session, const raii::rjp_string& batch, const rexy::string& timeout);
|
||||
|
||||
void repopulate(const session_info&);
|
||||
void invalidate(void);
|
||||
|
||||
private:
|
||||
static raii::string get_server_media_string(const raii::string_base& url);
|
||||
static rexy::string get_server_media_string(const rexy::string_base& url);
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
@ -19,7 +19,7 @@
|
||||
#ifndef MATRIX_ROOM_URL_LIST_HPP
|
||||
#define MATRIX_ROOM_URL_LIST_HPP
|
||||
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
#include "matrix/session_info.hpp"
|
||||
|
||||
namespace matrix{
|
||||
@ -27,35 +27,35 @@ namespace matrix{
|
||||
class room_url_list
|
||||
{
|
||||
private:
|
||||
raii::string m_typing;
|
||||
raii::string m_kick;
|
||||
raii::string m_ban;
|
||||
raii::string m_unban;
|
||||
raii::string m_invite;
|
||||
raii::string m_members;
|
||||
rexy::string m_typing;
|
||||
rexy::string m_kick;
|
||||
rexy::string m_ban;
|
||||
rexy::string m_unban;
|
||||
rexy::string m_invite;
|
||||
rexy::string m_members;
|
||||
public:
|
||||
room_url_list(const session_info& session, const raii::string_base& roomid);
|
||||
raii::string join(const session_info& session, const raii::string_base& roomid)const;
|
||||
raii::string leave(const session_info& session, const raii::string_base& roomid)const;
|
||||
raii::string forget(const session_info& session, const raii::string_base& roomid)const;
|
||||
raii::string upgrade(const session_info& session, const raii::string_base& roomid)const;
|
||||
raii::string read_receipt(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const;
|
||||
raii::string send(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventtype)const;
|
||||
raii::string redact(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const;
|
||||
raii::string event(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const;
|
||||
const raii::string& typing(void)const;
|
||||
const raii::string& kick(void)const;
|
||||
const raii::string& ban(void)const;
|
||||
const raii::string& unban(void)const;
|
||||
const raii::string& invite(void)const;
|
||||
const raii::string& room_members(void)const;
|
||||
raii::string messages(const session_info& session, const raii::string_base& roomid,
|
||||
const raii::string_base& from, const raii::string_base& to,
|
||||
const raii::string_base& dir, int limit)const;
|
||||
room_url_list(const session_info& session, const rexy::string_base& roomid);
|
||||
rexy::string join(const session_info& session, const rexy::string_base& roomid)const;
|
||||
rexy::string leave(const session_info& session, const rexy::string_base& roomid)const;
|
||||
rexy::string forget(const session_info& session, const rexy::string_base& roomid)const;
|
||||
rexy::string upgrade(const session_info& session, const rexy::string_base& roomid)const;
|
||||
rexy::string read_receipt(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const;
|
||||
rexy::string send(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventtype)const;
|
||||
rexy::string redact(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const;
|
||||
rexy::string event(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const;
|
||||
const rexy::string& typing(void)const;
|
||||
const rexy::string& kick(void)const;
|
||||
const rexy::string& ban(void)const;
|
||||
const rexy::string& unban(void)const;
|
||||
const rexy::string& invite(void)const;
|
||||
const rexy::string& room_members(void)const;
|
||||
rexy::string messages(const session_info& session, const rexy::string_base& roomid,
|
||||
const rexy::string_base& from, const rexy::string_base& to,
|
||||
const rexy::string_base& dir, int limit)const;
|
||||
|
||||
raii::string power_level(const session_info& session, const raii::string_base& roomid)const;
|
||||
rexy::string power_level(const session_info& session, const rexy::string_base& roomid)const;
|
||||
|
||||
void repopulate(const session_info& session, const raii::string_base& roomid);
|
||||
void repopulate(const session_info& session, const rexy::string_base& roomid);
|
||||
void invalidate_accesstoken(void);
|
||||
private:
|
||||
static constexpr const char* s_proto = "https://";
|
||||
|
||||
@ -21,13 +21,13 @@
|
||||
|
||||
#include "matrix/rest/urls_common.hpp"
|
||||
#include "matrix/session_info.hpp"
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
|
||||
namespace matrix::rest::session_urls{
|
||||
raii::string login(const session_info&);
|
||||
raii::string logout(const session_info&);
|
||||
raii::string password(const session_info&);
|
||||
raii::string whoami(const session_info&);
|
||||
rexy::string login(const session_info&);
|
||||
rexy::string logout(const session_info&);
|
||||
rexy::string password(const session_info&);
|
||||
rexy::string whoami(const session_info&);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
@ -19,13 +19,13 @@
|
||||
#ifndef MATRIX_REST_URLS_COMMON_HPP
|
||||
#define MATRIX_REST_URLS_COMMON_HPP
|
||||
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/string_base.hpp>
|
||||
|
||||
namespace matrix::rest{
|
||||
constexpr raii::static_string proto(void){
|
||||
constexpr rexy::static_string proto(void){
|
||||
return "https://"_ss;
|
||||
}
|
||||
constexpr raii::static_string revision(void){
|
||||
constexpr rexy::static_string revision(void){
|
||||
return "r0"_ss;
|
||||
}
|
||||
}
|
||||
|
||||
@ -21,7 +21,7 @@
|
||||
|
||||
#include "matrix/connection.hpp"
|
||||
#include "matrix/upload_info.hpp"
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
#include "raii/rjp_string.hpp"
|
||||
#include "matrix/rest/room_url_list.hpp"
|
||||
#include "matrix/iterable.hpp"
|
||||
@ -34,12 +34,12 @@ namespace matrix{
|
||||
class roomcxn : public connection
|
||||
{
|
||||
private:
|
||||
raii::string m_roomid;
|
||||
rexy::string m_roomid;
|
||||
room_url_list m_urls;
|
||||
|
||||
public:
|
||||
roomcxn(const std::shared_ptr<session_info>&, const raii::string_base& roomid);
|
||||
roomcxn(const std::shared_ptr<session_info>& ses, raii::string&& roomid);
|
||||
roomcxn(const std::shared_ptr<session_info>&, const rexy::string_base& roomid);
|
||||
roomcxn(const std::shared_ptr<session_info>& ses, rexy::string&& roomid);
|
||||
|
||||
roomcxn(const roomcxn&) = default;
|
||||
roomcxn(roomcxn&&) = default;
|
||||
@ -59,42 +59,42 @@ namespace matrix{
|
||||
netreturn<std::vector<raii::rjp_string>> members(void)const;
|
||||
|
||||
//member management
|
||||
netreturn<void> invite(const raii::string_base& userid);
|
||||
netreturn<void> invite(const rexy::string_base& userid);
|
||||
[[deprecated("Use roomcxn::kick instead")]]
|
||||
netreturn<void> uninvite(const raii::string_base& userid, const raii::string_base& reason = raii::string());
|
||||
netreturn<void> kick(const raii::string_base& userid, const raii::string_base& reason = raii::string());
|
||||
netreturn<void> ban(const raii::string_base& userid, const raii::string_base& reason = raii::string());
|
||||
netreturn<void> unban(const raii::string_base& userid);
|
||||
netreturn<void> uninvite(const rexy::string_base& userid, const rexy::string_base& reason = rexy::string());
|
||||
netreturn<void> kick(const rexy::string_base& userid, const rexy::string_base& reason = rexy::string());
|
||||
netreturn<void> ban(const rexy::string_base& userid, const rexy::string_base& reason = rexy::string());
|
||||
netreturn<void> unban(const rexy::string_base& userid);
|
||||
|
||||
//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_message(const raii::string_base& text)const;
|
||||
netreturn<raii::rjp_string> send_notice(const raii::string_base& text)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 rexy::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_image(const uploaded_image& image)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> forward_event(const sync::room_event&)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<raii::rjp_string> redact_event(const raii::string_base& eventid, const raii::string_base& reason)const;
|
||||
netreturn<raii::rjp_string> redact_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 rexy::string_base& eventid, const rexy::string_base& reason)const;
|
||||
netreturn<raii::rjp_string> redact_event(const rexy::string_base& eventid)const;
|
||||
|
||||
//recieve events
|
||||
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_forward(int amount, const raii::string_base& from, const raii::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_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 rexy::string_base& from, const rexy::string_base& to);
|
||||
|
||||
//meta stuff
|
||||
void regenerate_urls(void);
|
||||
netreturn<raii::rjp_string> upgrade(int version)const;
|
||||
|
||||
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<raii::rjp_string> _send_message(const raii::string_base& msg)const;
|
||||
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 rexy::string_base& msg)const;
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
@ -23,7 +23,7 @@
|
||||
#include "matrix/session_info.hpp"
|
||||
#include "matrix/auth.hpp"
|
||||
#include "raii/curler.hpp"
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
#include "matrix/connection.hpp"
|
||||
#include <utility> //pair
|
||||
|
||||
@ -64,8 +64,8 @@ namespace matrix{
|
||||
* NOT thread safe.
|
||||
* Set the useragent for the session and all spawned clients and syncers.
|
||||
*/
|
||||
void set_useragent(const raii::string_base&);
|
||||
void set_useragent(raii::string&&);
|
||||
void set_useragent(const rexy::string_base&);
|
||||
void set_useragent(rexy::string&&);
|
||||
|
||||
|
||||
/*
|
||||
@ -73,15 +73,15 @@ namespace matrix{
|
||||
* Set the access token for the session and all spawned clients and syncers.
|
||||
* Note this will not check if the access token is valid or not, nor will urls be updated.
|
||||
*/
|
||||
void set_access_token(const raii::string_base&);
|
||||
void set_access_token(raii::string&&);
|
||||
void set_access_token(const rexy::string_base&);
|
||||
void set_access_token(rexy::string&&);
|
||||
/*
|
||||
* NOT thread safe.
|
||||
* Set the homeserver for the session and all spawned clients and syncers.
|
||||
* Note this will not check if the homeserver is valid or not, nor will urs be updated.
|
||||
*/
|
||||
void set_homeserver(const raii::string_base&);
|
||||
void set_homeserver(raii::string&&);
|
||||
void set_homeserver(const rexy::string_base&);
|
||||
void set_homeserver(rexy::string&&);
|
||||
|
||||
/*
|
||||
* NOT thread safe.
|
||||
@ -97,7 +97,7 @@ namespace matrix{
|
||||
* homeserver are valid.
|
||||
* Returns: true if success, false otherwise.
|
||||
*/
|
||||
netreturn<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.
|
||||
@ -110,7 +110,7 @@ namespace matrix{
|
||||
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.
|
||||
* Note the client and session will share memory for generated urls, homeserver, access_token, and
|
||||
@ -127,11 +127,11 @@ namespace matrix{
|
||||
*/
|
||||
void invalidate(void);
|
||||
private:
|
||||
netreturn<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);
|
||||
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;
|
||||
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);
|
||||
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 rexy::string_base& name, const rexy::string_base& pass, const rexy::string_base& loginurl);
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
@ -19,15 +19,15 @@
|
||||
#ifndef MATRIX_SESSION_INFO_HPP
|
||||
#define MATRIX_SESSION_INFO_HPP
|
||||
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
#include "raii/rjp_string.hpp"
|
||||
|
||||
namespace matrix{
|
||||
struct session_info{
|
||||
raii::string useragent; //useragent to identify our application
|
||||
raii::string homeserver; //name of our homeserver
|
||||
rexy::string useragent; //useragent to identify our application
|
||||
rexy::string homeserver; //name of our homeserver
|
||||
raii::rjp_string access_token; //authentication
|
||||
raii::string auth_header;
|
||||
rexy::string auth_header;
|
||||
raii::rjp_string userid; //userid including homeserver
|
||||
};
|
||||
}
|
||||
|
||||
@ -19,7 +19,7 @@
|
||||
#ifndef 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_iterator.hpp"
|
||||
#include "raii/rjp_ptr.hpp"
|
||||
@ -38,7 +38,7 @@ namespace matrix::sync{
|
||||
RJP_value* m_room;
|
||||
public:
|
||||
constexpr room_event_response(RJP_value* room):m_room(room){}
|
||||
raii::static_string roomid(void)const;
|
||||
rexy::static_string roomid(void)const;
|
||||
room_event_list account_events(void);
|
||||
room_ephem_event_list ephemeral_events(void);
|
||||
room_state_event_list state_events(void);
|
||||
@ -129,7 +129,7 @@ namespace matrix::sync{
|
||||
raii::rjp_ptr m_root = nullptr;
|
||||
public:
|
||||
constexpr client_response(void) = default;
|
||||
client_response(const raii::string_base& src);
|
||||
client_response(const rexy::string_base& src);
|
||||
client_response(RJP_value* root);
|
||||
|
||||
room_list room_join_events(void)const;
|
||||
@ -137,7 +137,7 @@ namespace matrix::sync{
|
||||
room_list room_leave_events(void)const;
|
||||
|
||||
device_list device_lists(void)const;
|
||||
raii::static_string next_batch(void)const&;
|
||||
rexy::static_string next_batch(void)const&;
|
||||
raii::rjp_string next_batch(void)&&;
|
||||
|
||||
event_list to_device_events(void)const;
|
||||
|
||||
@ -20,8 +20,8 @@
|
||||
#define MATRIX_UPLOAD_INFO_HPP
|
||||
|
||||
#include "raii/rjp_string.hpp"
|
||||
#include "raii/string.hpp"
|
||||
#include "raii/binary.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
#include <rexy/binary.hpp>
|
||||
#include <cstdlib> //size_t
|
||||
|
||||
namespace matrix{
|
||||
@ -29,16 +29,16 @@ namespace matrix{
|
||||
class client;
|
||||
|
||||
struct file_details{
|
||||
raii::binary data;
|
||||
raii::string name;
|
||||
rexy::binary data;
|
||||
rexy::string name;
|
||||
};
|
||||
struct image_details : public file_details{
|
||||
int width, height;
|
||||
raii::string mimetype;
|
||||
rexy::string mimetype;
|
||||
};
|
||||
struct video_details : public image_details{};
|
||||
struct audio_details : public file_details{
|
||||
raii::string mimetype;
|
||||
rexy::string mimetype;
|
||||
};
|
||||
|
||||
class uploaded_file
|
||||
@ -46,8 +46,8 @@ namespace matrix{
|
||||
friend class matrix::client;
|
||||
protected:
|
||||
raii::rjp_string m_fileurl = {};
|
||||
raii::string m_filename = {};
|
||||
raii::string m_mimetype = {};
|
||||
rexy::string m_filename = {};
|
||||
rexy::string m_mimetype = {};
|
||||
size_t m_filesize = 0;
|
||||
|
||||
public:
|
||||
@ -61,8 +61,8 @@ namespace matrix{
|
||||
|
||||
constexpr operator bool(void)const{return m_fileurl;}
|
||||
|
||||
const raii::string& mimetype(void)const{return m_mimetype;}
|
||||
const raii::string& name(void)const{return m_filename;}
|
||||
const rexy::string& mimetype(void)const{return m_mimetype;}
|
||||
const rexy::string& name(void)const{return m_filename;}
|
||||
const raii::rjp_string& url(void)const{return m_fileurl;}
|
||||
constexpr size_t size(void)const{return m_filesize;}
|
||||
};
|
||||
@ -72,7 +72,7 @@ namespace matrix{
|
||||
friend class matrix::client;
|
||||
protected:
|
||||
raii::rjp_string m_url;
|
||||
raii::string m_mimetype;
|
||||
rexy::string m_mimetype;
|
||||
size_t m_width = 0;
|
||||
size_t m_height = 0;
|
||||
size_t m_size = 0;
|
||||
@ -92,7 +92,7 @@ namespace matrix{
|
||||
constexpr size_t height(void)const{return m_height;}
|
||||
constexpr size_t size(void)const{return m_size;}
|
||||
const raii::rjp_string& url(void)const{return m_url;}
|
||||
const raii::string& mimetype(void)const{return m_mimetype;}
|
||||
const rexy::string& mimetype(void)const{return m_mimetype;}
|
||||
};
|
||||
class uploaded_image : public uploaded_file
|
||||
{
|
||||
|
||||
@ -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
|
||||
@ -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
|
||||
@ -19,7 +19,7 @@
|
||||
#ifndef RAII_CURL_STRING_HPP
|
||||
#define RAII_CURL_STRING_HPP
|
||||
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/string_base.hpp>
|
||||
|
||||
#include <curl/curl.h>
|
||||
#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>;
|
||||
|
||||
|
||||
}
|
||||
|
||||
@ -54,13 +54,13 @@ namespace raii{
|
||||
curler& getreq(void);
|
||||
curler& setheader(const curl_llist& h);
|
||||
curler& seturl(const char* s);
|
||||
curler& seturl(const string_base& s);
|
||||
curler& seturl(const rexy::string_base& s);
|
||||
curler& setuseragent(const char* s);
|
||||
curler& setuseragent(const string_base& s);
|
||||
curler& setuseragent(const rexy::string_base& s);
|
||||
curler& setuserpwd(const char* s);
|
||||
curler& setuserpwd(const string_base& s);
|
||||
curler& setuserpwd(const rexy::string_base& s);
|
||||
curler& setpostdata(const char* s, curl_off_t len = -1);
|
||||
curler& setpostdata(const string_base& s);
|
||||
curler& setpostdata(const rexy::string_base& s);
|
||||
curler& forcessl(long version = CURL_SSLVERSION_DEFAULT);
|
||||
curler& setwritefun(write_function);
|
||||
curler& setwritedata(void*);
|
||||
|
||||
@ -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
|
||||
@ -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
|
||||
@ -43,7 +43,7 @@ namespace raii{
|
||||
m_root(std::exchange(e.m_root, nullptr)),
|
||||
m_obj(e.m_obj)
|
||||
{
|
||||
e.m_obj = RJP_object_iterator{0};
|
||||
e.m_obj = {};
|
||||
}
|
||||
rjp_object_iterator& operator=(rjp_object_iterator&& e){
|
||||
std::swap(m_root, e.m_root);
|
||||
|
||||
@ -20,7 +20,7 @@
|
||||
#define RAII_RJP_STRING_HPP
|
||||
|
||||
#include <rjp.h>
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/string_base.hpp>
|
||||
#include <utility> //exchange
|
||||
#include <cstdlib> //memcpy
|
||||
|
||||
@ -39,16 +39,16 @@ namespace raii{
|
||||
}
|
||||
|
||||
//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(rjp_string&&) = default;
|
||||
rjp_string& operator=(const 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):
|
||||
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)
|
||||
{
|
||||
@ -59,7 +59,7 @@ namespace raii{
|
||||
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){
|
||||
if(!r)
|
||||
return *this;
|
||||
|
||||
@ -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
|
||||
@ -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
|
||||
@ -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
|
||||
@ -19,7 +19,7 @@
|
||||
#ifndef RAII_UTIL_HPP
|
||||
#define RAII_UTIL_HPP
|
||||
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
|
||||
namespace raii{
|
||||
|
||||
@ -44,20 +44,20 @@ namespace raii{
|
||||
return len;
|
||||
}
|
||||
}
|
||||
template<class T, typename std::enable_if<detail::is_string<T>::value && !detail::is_concrete_string<T>::value,void>::type* = nullptr>
|
||||
string json_escape(T&& t){
|
||||
template<class T, typename std::enable_if<rexy::detail::is_string<T>::value && !rexy::detail::is_concrete_string<T>::value,void>::type* = nullptr>
|
||||
rexy::string json_escape(T&& t){
|
||||
auto tup = t.get();
|
||||
size_t len = detail::_calc_escaped_len_all(tup);
|
||||
char* tmp = reinterpret_cast<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);
|
||||
tmp[len] = 0;
|
||||
return string(tmp, len);
|
||||
return rexy::string(tmp, len);
|
||||
}
|
||||
string json_escape(const string_base& str);
|
||||
rexy::string json_escape(const rexy::string_base& str);
|
||||
|
||||
|
||||
size_t intlen(int i);
|
||||
raii::string itostr(int i);
|
||||
rexy::string itostr(int i);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
2
makefile
2
makefile
@ -32,7 +32,7 @@ RELEASE?=0
|
||||
|
||||
ifneq ($(WINDOWS),1)
|
||||
CXX::=g++
|
||||
LDLIBS::=-lcurl -lrjp
|
||||
LDLIBS::=-lcurl -lrjp -lrexy
|
||||
LDFLAGS::=
|
||||
STRIP::=strip
|
||||
RANLIB::=ranlib
|
||||
|
||||
@ -19,8 +19,8 @@
|
||||
#include "matrix/client.hpp"
|
||||
#include "matrix/fat_strings.hpp"
|
||||
#include "matrix/json_targets.hpp"
|
||||
#include "raii/filerd.hpp"
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/filerd.hpp>
|
||||
#include <rexy/string_base.hpp>
|
||||
#include "raii/rjp_ptr.hpp"
|
||||
#include "raii/util.hpp"
|
||||
|
||||
@ -32,19 +32,19 @@ namespace matrix{
|
||||
m_urls(std::make_shared<matrix::rest::client_url_list>(*ses)){}
|
||||
|
||||
//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());
|
||||
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());
|
||||
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());
|
||||
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());
|
||||
}
|
||||
|
||||
@ -52,18 +52,18 @@ namespace matrix{
|
||||
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());
|
||||
}
|
||||
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());
|
||||
}
|
||||
netreturn<raii::rjp_string> client::get_profile_picture(void)const{
|
||||
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());
|
||||
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{
|
||||
raii::string reply = _get_curl(m_urls->room_list());
|
||||
rexy::string reply = _get_curl(m_urls->room_list());
|
||||
if(!reply)
|
||||
return _create_netreturn(reply, http_status());
|
||||
|
||||
@ -86,13 +86,13 @@ namespace matrix{
|
||||
}
|
||||
|
||||
//room membership
|
||||
netreturn<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());
|
||||
}
|
||||
roomcxn client::spawn_room(const raii::string_base& roomid)const{
|
||||
roomcxn client::spawn_room(const rexy::string_base& roomid)const{
|
||||
return roomcxn(m_ses, roomid);
|
||||
}
|
||||
roomcxn client::spawn_room(raii::string&& roomid)const{
|
||||
roomcxn client::spawn_room(rexy::string&& roomid)const{
|
||||
return roomcxn(m_ses, std::move(roomid));
|
||||
}
|
||||
|
||||
@ -101,7 +101,7 @@ namespace matrix{
|
||||
return _upload_file(file, raii::curl_llist{});
|
||||
}
|
||||
netreturn<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_image> retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus());
|
||||
retval.value().m_width = file.width;
|
||||
@ -110,14 +110,14 @@ namespace matrix{
|
||||
return retval;
|
||||
}
|
||||
netreturn<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_audio> retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus());
|
||||
retval.value().m_mimetype = file.mimetype;
|
||||
return retval;
|
||||
}
|
||||
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_video> retval(std::move(upfile.mxerror()), std::move(upfile.mxerrorcode()), upfile.httpstatus());
|
||||
retval.value().m_width = file.width;
|
||||
@ -127,7 +127,7 @@ namespace matrix{
|
||||
}
|
||||
|
||||
static size_t _thumbnail_header_callback(char* ptr, size_t size, size_t nmemb, void* userdata){
|
||||
raii::string* data = reinterpret_cast<raii::string*>(userdata);
|
||||
rexy::string* data = reinterpret_cast<rexy::string*>(userdata);
|
||||
if(size*nmemb > 13 && !strncmp("Content-Type:", ptr, 13)){
|
||||
(*data) += (ptr + 13);
|
||||
data->get()[data->length()-1] = 0;
|
||||
@ -137,7 +137,7 @@ namespace matrix{
|
||||
|
||||
netreturn<void> client::create_thumbnail(uploaded_image& info)const{
|
||||
image_details i;
|
||||
raii::string reply_header;
|
||||
rexy::string reply_header;
|
||||
if(info.thumb_width() > info.width() || info.thumb_height() > info.height()){
|
||||
info.m_thumb.m_url = info.m_fileurl;
|
||||
info.m_thumb.m_size = info.m_filesize;
|
||||
@ -149,7 +149,7 @@ namespace matrix{
|
||||
m_curl.setopt(CURLOPT_HEADERFUNCTION, NULL);
|
||||
m_curl.setopt(CURLOPT_HEADERDATA, NULL);
|
||||
if(!i.data)
|
||||
return netreturn<void>(raii::string(), raii::string(), http_status());
|
||||
return netreturn<void>(rexy::string(), rexy::string(), http_status());
|
||||
i.width = info.thumb_width();
|
||||
i.height = info.thumb_height();
|
||||
i.mimetype = std::move(reply_header);
|
||||
@ -165,21 +165,21 @@ namespace matrix{
|
||||
netreturn<void> client::create_thumbnail(uploaded_video& info)const{
|
||||
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));
|
||||
}
|
||||
netreturn<sync::client_response> client::sync(size_t timeout){
|
||||
return sync(timeout, {});
|
||||
}
|
||||
netreturn<sync::client_response> client::sync(size_t timeout, const sync::client_response& last){
|
||||
raii::string reply;
|
||||
rexy::string reply;
|
||||
if(last.raw_handle())
|
||||
reply = _get_curl(m_urls->sync(*m_ses, last.next_batch(), raii::itostr(timeout)));
|
||||
else
|
||||
reply = _get_curl(m_urls->sync(*m_ses, ""_ss, raii::itostr(timeout)));
|
||||
|
||||
if(!reply)
|
||||
return netreturn<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));
|
||||
netreturn<sync::client_response> retval = _create_netreturn(root, http_status());
|
||||
if(!root)
|
||||
@ -210,7 +210,7 @@ namespace matrix{
|
||||
}
|
||||
|
||||
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()};
|
||||
m_curl.postreq();
|
||||
m_curl.setopt(CURLOPT_POSTFIELDS, NULL);
|
||||
|
||||
@ -18,7 +18,7 @@
|
||||
|
||||
#include "matrix/connection.hpp"
|
||||
#include "raii/rjp_ptr.hpp"
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/string_base.hpp>
|
||||
#include <cstdlib> //size_t
|
||||
#include <algorithm> //min, max
|
||||
|
||||
@ -37,7 +37,7 @@ namespace matrix{
|
||||
const raii::rjp_string& connection::userid(void)const{
|
||||
return m_ses->userid;
|
||||
}
|
||||
const raii::string& connection::useragent(void)const{
|
||||
const rexy::string& connection::useragent(void)const{
|
||||
return m_ses->useragent;
|
||||
}
|
||||
|
||||
@ -46,21 +46,21 @@ namespace matrix{
|
||||
}
|
||||
|
||||
size_t connection::_reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata){
|
||||
raii::string* data = reinterpret_cast<raii::string*>(userdata);
|
||||
rexy::string* data = reinterpret_cast<rexy::string*>(userdata);
|
||||
data->append(ptr, size*nmemb);
|
||||
return size*nmemb;
|
||||
}
|
||||
size_t connection::_binary_reply_curl_callback(char* ptr, size_t size, size_t nmemb, void* userdata){
|
||||
raii::binary* data = reinterpret_cast<raii::binary*>(userdata);
|
||||
rexy::binary* data = reinterpret_cast<rexy::binary*>(userdata);
|
||||
data->append(ptr, size*nmemb);
|
||||
return size*nmemb;
|
||||
}
|
||||
void connection::_get_curl_setup(const raii::string_base& url)const{
|
||||
void connection::_get_curl_setup(const rexy::string_base& url)const{
|
||||
m_curl.getreq();
|
||||
m_curl.seturl(url);
|
||||
m_curl.setheader(raii::curl_llist{});
|
||||
}
|
||||
void connection::_post_curl_setup(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header)const{
|
||||
void connection::_post_curl_setup(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header)const{
|
||||
m_curl.postreq();
|
||||
m_curl.setpostdata(postdata.get(), postdata.length());
|
||||
m_curl.seturl(url);
|
||||
@ -75,7 +75,7 @@ namespace matrix{
|
||||
src->data += to_copy;
|
||||
return to_copy;
|
||||
}
|
||||
void connection::_put_curl_setup(put_data& data, const raii::string_base& url, const raii::curl_llist& header)const{
|
||||
void connection::_put_curl_setup(put_data& data, const rexy::string_base& url, const raii::curl_llist& header)const{
|
||||
m_curl.putreq();
|
||||
m_curl.setopt(CURLOPT_POSTFIELDS, data.data);
|
||||
m_curl.setopt(CURLOPT_POSTFIELDSIZE_LARGE, (curl_off_t)data.len);
|
||||
@ -86,15 +86,15 @@ namespace matrix{
|
||||
m_curl.setopt(CURLOPT_INFILESIZE, (curl_off_t)data.len);
|
||||
}
|
||||
|
||||
void connection::_set_curl_useragent(const raii::string_base& useragent){
|
||||
void connection::_set_curl_useragent(const rexy::string_base& useragent){
|
||||
m_curl.setuseragent(useragent);
|
||||
}
|
||||
bool connection::_perform_curl(void)const{
|
||||
CURLcode res = m_curl.perform();
|
||||
return (res == CURLE_OK);
|
||||
}
|
||||
raii::string connection::_get_curl(const raii::string_base& url, reply_callback_fun fun)const{
|
||||
raii::string reply;
|
||||
rexy::string connection::_get_curl(const rexy::string_base& url, reply_callback_fun fun)const{
|
||||
rexy::string reply;
|
||||
_get_curl_setup(url);
|
||||
m_curl.setwritefun(fun);
|
||||
m_curl.setwritedata(&reply);
|
||||
@ -102,8 +102,8 @@ namespace matrix{
|
||||
return {};
|
||||
return reply;
|
||||
}
|
||||
raii::binary connection::_get_curl_binary(const raii::string_base& url, binary_callback_fun fun)const{
|
||||
raii::binary reply;
|
||||
rexy::binary connection::_get_curl_binary(const rexy::string_base& url, binary_callback_fun fun)const{
|
||||
rexy::binary reply;
|
||||
_get_curl_setup(url);
|
||||
m_curl.setwritefun(fun);
|
||||
m_curl.setwritedata(&reply);
|
||||
@ -111,8 +111,8 @@ namespace matrix{
|
||||
return {};
|
||||
return reply;
|
||||
}
|
||||
raii::string connection::_post_curl(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, reply_callback_fun fun)const{
|
||||
raii::string reply;
|
||||
rexy::string connection::_post_curl(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, reply_callback_fun fun)const{
|
||||
rexy::string reply;
|
||||
_post_curl_setup(postdata, url, header);
|
||||
m_curl.setwritefun(fun);
|
||||
m_curl.setwritedata(&reply);
|
||||
@ -120,8 +120,8 @@ namespace matrix{
|
||||
return {};
|
||||
return reply;
|
||||
}
|
||||
raii::binary connection::_post_curl_binary(const raii::string_base& postdata, const raii::string_base& url, const raii::curl_llist& header, binary_callback_fun fun)const{
|
||||
raii::binary reply;
|
||||
rexy::binary connection::_post_curl_binary(const rexy::string_base& postdata, const rexy::string_base& url, const raii::curl_llist& header, binary_callback_fun fun)const{
|
||||
rexy::binary reply;
|
||||
_post_curl_setup(postdata, url, header);
|
||||
m_curl.setwritefun(fun);
|
||||
m_curl.setwritedata(&reply);
|
||||
@ -129,8 +129,8 @@ namespace matrix{
|
||||
return {};
|
||||
return reply;
|
||||
}
|
||||
raii::string connection::_put_curl(const raii::string_base& putdata, const raii::string_base& url, const raii::curl_llist& header, reply_callback_fun fun)const{
|
||||
raii::string reply;
|
||||
rexy::string connection::_put_curl(const rexy::string_base& putdata, const rexy::string_base& url, const raii::curl_llist& header, reply_callback_fun fun)const{
|
||||
rexy::string reply;
|
||||
put_data data{putdata.get(), putdata.length()};
|
||||
m_curl.setwritefun(fun);
|
||||
m_curl.setwritedata(&reply);
|
||||
@ -142,8 +142,8 @@ namespace matrix{
|
||||
return {};
|
||||
return reply;
|
||||
}
|
||||
raii::binary connection::_put_curl_binary(const raii::string_base& putdata, const raii::string_base& url, const raii::curl_llist& header, binary_callback_fun fun)const{
|
||||
raii::binary reply;
|
||||
rexy::binary connection::_put_curl_binary(const rexy::string_base& putdata, const rexy::string_base& url, const raii::curl_llist& header, binary_callback_fun fun)const{
|
||||
rexy::binary reply;
|
||||
put_data data{putdata.get(), putdata.length()};
|
||||
m_curl.setwritefun(fun);
|
||||
m_curl.setwritedata(&reply);
|
||||
@ -155,10 +155,10 @@ namespace matrix{
|
||||
return {};
|
||||
return reply;
|
||||
}
|
||||
netreturn<raii::rjp_string> connection::_post_and_find(const raii::string_base& data, const raii::string_base& url,
|
||||
const raii::curl_llist& header, const raii::string_base& target)const
|
||||
netreturn<raii::rjp_string> connection::_post_and_find(const rexy::string_base& data, const rexy::string_base& url,
|
||||
const raii::curl_llist& header, const rexy::string_base& target)const
|
||||
{
|
||||
raii::string reply = _post_curl(data, url, header);
|
||||
rexy::string reply = _post_curl(data, url, header);
|
||||
if(!reply)
|
||||
return _create_netreturn(reply, http_status());
|
||||
raii::rjp_ptr root(rjp_parse(reply));
|
||||
@ -166,10 +166,10 @@ namespace matrix{
|
||||
retval.value() = _curl_reply_search(reply, target);
|
||||
return retval;
|
||||
}
|
||||
netreturn<raii::rjp_string> connection::_put_and_find(const raii::string_base& data, const raii::string_base& url,
|
||||
const raii::curl_llist& header, const raii::string_base& target)const
|
||||
netreturn<raii::rjp_string> connection::_put_and_find(const rexy::string_base& data, const rexy::string_base& url,
|
||||
const raii::curl_llist& header, const rexy::string_base& target)const
|
||||
{
|
||||
raii::string reply = _put_curl(data, url, header);
|
||||
rexy::string reply = _put_curl(data, url, header);
|
||||
if(!reply)
|
||||
return _create_netreturn(reply, http_status());
|
||||
raii::rjp_ptr root(rjp_parse(reply));
|
||||
@ -177,8 +177,8 @@ namespace matrix{
|
||||
retval.value() = _curl_reply_search(reply, target);
|
||||
return retval;
|
||||
}
|
||||
netreturn<raii::rjp_string> connection::_get_and_find(const raii::string_base& url, const raii::string_base& target)const{
|
||||
raii::string reply = _get_curl(url);
|
||||
netreturn<raii::rjp_string> connection::_get_and_find(const rexy::string_base& url, const rexy::string_base& target)const{
|
||||
rexy::string reply = _get_curl(url);
|
||||
if(!reply)
|
||||
return _create_netreturn(reply, http_status());
|
||||
raii::rjp_ptr root(rjp_parse(reply));
|
||||
@ -186,11 +186,11 @@ namespace matrix{
|
||||
retval.value() = _curl_reply_search(reply, target);
|
||||
return retval;
|
||||
}
|
||||
raii::rjp_string connection::_curl_reply_search(const raii::string_base& reply, const raii::string_base& target)const{
|
||||
raii::rjp_string connection::_curl_reply_search(const rexy::string_base& reply, const rexy::string_base& target)const{
|
||||
raii::rjp_ptr root(rjp_parse(reply));
|
||||
return _curl_reply_search(root, target);
|
||||
}
|
||||
raii::rjp_string connection::_curl_reply_search(const raii::rjp_ptr& root, const raii::string_base& target)const{
|
||||
raii::rjp_string connection::_curl_reply_search(const raii::rjp_ptr& root, const rexy::string_base& target)const{
|
||||
if(!root)
|
||||
return {};
|
||||
RJP_value* res = rjp_search_member(root.get(), target.get());
|
||||
@ -201,7 +201,7 @@ namespace matrix{
|
||||
return raii::rjp_string(res);
|
||||
|
||||
}
|
||||
void connection::_set_curl_defaults(const raii::string_base& useragent)const{
|
||||
void connection::_set_curl_defaults(const rexy::string_base& useragent)const{
|
||||
#ifdef _WIN32
|
||||
//temporary measure to make ssl connections work on wine
|
||||
m_curl.setopt(CURLOPT_CAINFO, "./cacert.pem");
|
||||
@ -215,7 +215,7 @@ namespace matrix{
|
||||
m_curl.setopt(CURLOPT_TCP_KEEPALIVE, 1L);
|
||||
//m_curl.setopt(CURLOPT_FAILONERROR, 0L);
|
||||
}
|
||||
netreturn_base connection::_create_netreturn(const raii::string_base& mxjson, int httpstatus){
|
||||
netreturn_base connection::_create_netreturn(const rexy::string_base& mxjson, int httpstatus){
|
||||
if(!mxjson)
|
||||
return netreturn_base(""_ss, ""_ss, httpstatus);
|
||||
raii::rjp_ptr root(rjp_parse(mxjson.get()));
|
||||
|
||||
@ -30,8 +30,8 @@ namespace matrix::sync{
|
||||
m_event(std::exchange(ev.m_event, nullptr)),
|
||||
m_type(std::exchange(ev.m_type, nullptr)),
|
||||
m_content(std::exchange(ev.m_content, nullptr)){}
|
||||
raii::static_string event::type(void)const&{
|
||||
return raii::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length);
|
||||
rexy::static_string event::type(void)const&{
|
||||
return rexy::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length);
|
||||
}
|
||||
raii::rjp_string event::type(void)&&{
|
||||
return raii::rjp_string(std::exchange(m_type, nullptr));
|
||||
@ -50,7 +50,7 @@ namespace matrix::sync{
|
||||
}
|
||||
|
||||
//Room event
|
||||
room_event::room_event(RJP_value* ev, const raii::string_base& roomid):
|
||||
room_event::room_event(RJP_value* ev, const rexy::string_base& roomid):
|
||||
room_event_base(roomid), event(ev)
|
||||
{
|
||||
if(!ev)
|
||||
@ -68,15 +68,15 @@ namespace matrix::sync{
|
||||
m_unsigned(std::exchange(ev.m_unsigned, nullptr)),
|
||||
m_redacts(std::exchange(ev.m_redacts, nullptr)),
|
||||
m_origin_server_ts(ev.m_origin_server_ts){}
|
||||
raii::static_string room_event::eventid(void)const&{
|
||||
return raii::static_string(rjp_get_cstring(m_id)->value, rjp_get_cstring(m_id)->length);
|
||||
rexy::static_string room_event::eventid(void)const&{
|
||||
return rexy::static_string(rjp_get_cstring(m_id)->value, rjp_get_cstring(m_id)->length);
|
||||
}
|
||||
|
||||
raii::rjp_string room_event::eventid(void)&&{
|
||||
return raii::rjp_string(std::exchange(m_id, nullptr));
|
||||
}
|
||||
raii::static_string room_event::sender(void)const&{
|
||||
return raii::static_string(rjp_get_cstring(m_sender)->value, rjp_get_cstring(m_sender)->length);
|
||||
rexy::static_string room_event::sender(void)const&{
|
||||
return rexy::static_string(rjp_get_cstring(m_sender)->value, rjp_get_cstring(m_sender)->length);
|
||||
}
|
||||
raii::rjp_string room_event::sender(void)&&{
|
||||
return raii::rjp_string(std::exchange(m_sender, nullptr));
|
||||
@ -90,10 +90,10 @@ namespace matrix::sync{
|
||||
RJP_value* room_event::extra(void){
|
||||
return m_unsigned;
|
||||
}
|
||||
raii::static_string room_event::redacts(void)const&{
|
||||
rexy::static_string room_event::redacts(void)const&{
|
||||
if(!m_redacts)
|
||||
return raii::static_string();
|
||||
return raii::static_string(rjp_get_cstring(m_redacts)->value, rjp_get_cstring(m_redacts)->length);
|
||||
return rexy::static_string();
|
||||
return rexy::static_string(rjp_get_cstring(m_redacts)->value, rjp_get_cstring(m_redacts)->length);
|
||||
}
|
||||
raii::rjp_string room_event::redacts(void)&&{
|
||||
if(!m_redacts)
|
||||
@ -102,7 +102,7 @@ namespace matrix::sync{
|
||||
}
|
||||
|
||||
//Room state event
|
||||
room_state_event::room_state_event(RJP_value* ev, const raii::string_base& roomid):
|
||||
room_state_event::room_state_event(RJP_value* ev, const rexy::string_base& roomid):
|
||||
room_event(ev, roomid)
|
||||
{
|
||||
if(!ev)
|
||||
@ -113,24 +113,24 @@ namespace matrix::sync{
|
||||
m_prev_content = rjp_search_member(m_unsigned, json::keys::event::prev_content());
|
||||
}
|
||||
}
|
||||
raii::static_string room_state_event::state_key(void)const&{
|
||||
return raii::static_string(rjp_get_cstring(m_state_key)->value, rjp_get_cstring(m_state_key)->length);
|
||||
rexy::static_string room_state_event::state_key(void)const&{
|
||||
return rexy::static_string(rjp_get_cstring(m_state_key)->value, rjp_get_cstring(m_state_key)->length);
|
||||
}
|
||||
raii::rjp_string room_state_event::state_key(void)&&{
|
||||
return raii::rjp_string(std::exchange(m_state_key, nullptr));
|
||||
}
|
||||
raii::static_string room_state_event::prev_content(void)const&{
|
||||
return raii::static_string(rjp_get_cstring(m_prev_content)->value, rjp_get_cstring(m_prev_content)->length);
|
||||
rexy::static_string room_state_event::prev_content(void)const&{
|
||||
return rexy::static_string(rjp_get_cstring(m_prev_content)->value, rjp_get_cstring(m_prev_content)->length);
|
||||
}
|
||||
raii::rjp_string room_state_event::prev_content(void)&&{
|
||||
return raii::rjp_string(std::exchange(m_prev_content, nullptr));
|
||||
}
|
||||
|
||||
room_ephemeral_event::room_ephemeral_event(RJP_value* ev, const raii::string_base& roomid):
|
||||
room_ephemeral_event::room_ephemeral_event(RJP_value* ev, const rexy::string_base& roomid):
|
||||
room_event_base(roomid), event(ev){}
|
||||
|
||||
//Room message event
|
||||
room_message_event::room_message_event(RJP_value* ev, const raii::string_base& roomid):
|
||||
room_message_event::room_message_event(RJP_value* ev, const rexy::string_base& roomid):
|
||||
room_event(ev, roomid),
|
||||
m_body(rjp_search_member(m_content, json::keys::event::contentbody::body())),
|
||||
m_type(rjp_search_member(m_content, json::keys::event::contentbody::msgtype())){}
|
||||
@ -138,14 +138,14 @@ namespace matrix::sync{
|
||||
room_event(std::move(ev)),
|
||||
m_body(rjp_search_member(m_content, json::keys::event::contentbody::body())),
|
||||
m_type(rjp_search_member(m_content, json::keys::event::contentbody::msgtype())){}
|
||||
raii::static_string room_message_event::body(void)const&{
|
||||
return raii::static_string(rjp_get_cstring(m_body)->value, rjp_get_cstring(m_body)->length);
|
||||
rexy::static_string room_message_event::body(void)const&{
|
||||
return rexy::static_string(rjp_get_cstring(m_body)->value, rjp_get_cstring(m_body)->length);
|
||||
}
|
||||
raii::rjp_string room_message_event::body(void)&&{
|
||||
return raii::rjp_string(m_body);
|
||||
}
|
||||
raii::static_string room_message_event::msgtype(void)const&{
|
||||
return raii::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length);
|
||||
rexy::static_string room_message_event::msgtype(void)const&{
|
||||
return rexy::static_string(rjp_get_cstring(m_type)->value, rjp_get_cstring(m_type)->length);
|
||||
}
|
||||
raii::rjp_string room_message_event::msgtype(void)&&{
|
||||
return raii::rjp_string(m_type);
|
||||
|
||||
@ -18,24 +18,24 @@
|
||||
|
||||
#include "matrix/fat_strings.hpp"
|
||||
#include "matrix/upload_info.hpp"
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/string_base.hpp>
|
||||
#include "matrix/json_targets.hpp"
|
||||
#include "raii/util.hpp"
|
||||
|
||||
namespace matrix::json{
|
||||
static constexpr auto quote(const raii::string_base& str){
|
||||
static constexpr auto quote(const rexy::string_base& str){
|
||||
return "\"" + str + "\"";
|
||||
}
|
||||
static constexpr auto key(const raii::string_base& str){
|
||||
static constexpr auto key(const rexy::string_base& str){
|
||||
return "\"" + str + "\":";
|
||||
}
|
||||
static constexpr raii::static_string open_brace(void){
|
||||
static constexpr rexy::static_string open_brace(void){
|
||||
return "{"_ss;
|
||||
}
|
||||
static constexpr raii::static_string close_brace(void){
|
||||
static constexpr rexy::static_string close_brace(void){
|
||||
return "}"_ss;
|
||||
}
|
||||
static constexpr raii::static_string comma(void){
|
||||
static constexpr rexy::static_string comma(void){
|
||||
return ","_ss;
|
||||
}
|
||||
template<class Arg, class... Args>
|
||||
@ -55,18 +55,18 @@ namespace matrix::json{
|
||||
return key(k) + value;
|
||||
}
|
||||
|
||||
raii::static_string _empty(void){
|
||||
rexy::static_string _empty(void){
|
||||
return "{}"_ss;
|
||||
}
|
||||
raii::string _image_body(const uploaded_image& image){
|
||||
raii::string url = raii::json_escape(image.url());
|
||||
const raii::string_base* thumburl;
|
||||
rexy::string _image_body(const uploaded_image& image){
|
||||
rexy::string url = raii::json_escape(image.url());
|
||||
const rexy::string_base* thumburl;
|
||||
if(image.thumb_url())
|
||||
thumburl = &image.thumb_url();
|
||||
else
|
||||
thumburl = &url;
|
||||
|
||||
return raii::string(
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::event::contentbody::body(), quote(raii::json_escape(image.name()))),
|
||||
member(json::keys::event::contentbody::info(), object(
|
||||
@ -87,8 +87,8 @@ namespace matrix::json{
|
||||
));
|
||||
}
|
||||
|
||||
raii::string _video_body(const uploaded_video& video){
|
||||
return raii::string(
|
||||
rexy::string _video_body(const uploaded_video& video){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::event::contentbody::body(), quote(raii::json_escape(video.name()))),
|
||||
member(json::keys::event::contentbody::info(), object(
|
||||
@ -108,8 +108,8 @@ namespace matrix::json{
|
||||
member(json::keys::event::contentbody::url(), quote(raii::json_escape(video.url())))
|
||||
));
|
||||
}
|
||||
raii::string _file_body(const uploaded_file& file){
|
||||
return raii::string(
|
||||
rexy::string _file_body(const uploaded_file& file){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::event::contentbody::body(), quote(raii::json_escape(file.name()))),
|
||||
member(json::keys::event::contentbody::info(), object(
|
||||
@ -120,8 +120,8 @@ namespace matrix::json{
|
||||
));
|
||||
}
|
||||
|
||||
raii::string _audio_body(const uploaded_audio& audio){
|
||||
return raii::string(
|
||||
rexy::string _audio_body(const uploaded_audio& audio){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::event::contentbody::body(), quote(raii::json_escape(audio.name()))),
|
||||
member(json::keys::event::contentbody::info(), object(
|
||||
@ -133,22 +133,22 @@ namespace matrix::json{
|
||||
));
|
||||
}
|
||||
|
||||
raii::string _message_body(const raii::string_base& msg){
|
||||
return raii::string(
|
||||
rexy::string _message_body(const rexy::string_base& msg){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::event::contentbody::body(), quote(raii::json_escape(msg))),
|
||||
member(json::keys::event::contentbody::msgtype(), quote("m.text"_ss))
|
||||
));
|
||||
}
|
||||
raii::string _notice_body(const raii::string_base& msg){
|
||||
return raii::string(
|
||||
rexy::string _notice_body(const rexy::string_base& msg){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::event::contentbody::body(), quote(raii::json_escape(msg))),
|
||||
member(json::keys::event::contentbody::msgtype(), quote("m.notice"_ss))
|
||||
));
|
||||
}
|
||||
raii::string _login_password(const raii::string_base& username, const raii::string_base& password){
|
||||
return raii::string(
|
||||
rexy::string _login_password(const rexy::string_base& username, const rexy::string_base& password){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::auth::type(), quote("m.login.password"_ss)),
|
||||
member(json::keys::auth::identifier(), object(
|
||||
@ -158,8 +158,8 @@ namespace matrix::json{
|
||||
member(json::keys::auth::password(), quote(raii::json_escape(password)))
|
||||
));
|
||||
}
|
||||
raii::string _change_psk_password(const raii::string_base& userid, const raii::string_base& newpass, const raii::string_base& oldpass, const raii::string_base& session){
|
||||
return raii::string(
|
||||
rexy::string _change_psk_password(const rexy::string_base& userid, const rexy::string_base& newpass, const rexy::string_base& oldpass, const rexy::string_base& session){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::auth::newpassword(), quote(raii::json_escape(newpass))),
|
||||
member(json::keys::auth::auth(), object(
|
||||
@ -170,66 +170,66 @@ namespace matrix::json{
|
||||
))
|
||||
));
|
||||
}
|
||||
raii::string _displayname_set(const raii::string_base& newname){
|
||||
return raii::string(
|
||||
rexy::string _displayname_set(const rexy::string_base& newname){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::displayname(), quote(raii::json_escape(newname)))
|
||||
));
|
||||
}
|
||||
raii::string _avatar_set(const raii::string_base& mediaurl){
|
||||
return raii::string(
|
||||
rexy::string _avatar_set(const rexy::string_base& mediaurl){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::avatarurl(), quote(raii::json_escape(mediaurl)))
|
||||
));
|
||||
}
|
||||
raii::string _presence_set(const raii::string_base& status){
|
||||
return raii::string(
|
||||
rexy::string _presence_set(const rexy::string_base& status){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::presence(), quote(status))
|
||||
));
|
||||
}
|
||||
raii::string _create_room(const raii::string_base& name, const raii::string_base& alias){
|
||||
rexy::string _create_room(const rexy::string_base& name, const rexy::string_base& alias){
|
||||
if(alias){
|
||||
return raii::string(
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::name(), quote(raii::json_escape(name))),
|
||||
member(json::keys::roomaliasname(), quote(raii::json_escape(alias)))
|
||||
));
|
||||
}else{
|
||||
return raii::string(
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::name(), quote(raii::json_escape(name)))
|
||||
));
|
||||
}
|
||||
}
|
||||
raii::string _userid(const raii::string_base& id){
|
||||
return raii::string(
|
||||
rexy::string _userid(const rexy::string_base& id){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::auth::userid(), quote(raii::json_escape(id)))
|
||||
));
|
||||
}
|
||||
raii::string _userid_reason(const raii::string_base& id, const raii::string_base& reason){
|
||||
return raii::string(
|
||||
rexy::string _userid_reason(const rexy::string_base& id, const rexy::string_base& reason){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::auth::userid(), quote(raii::json_escape(id))),
|
||||
member(json::reason(), quote(raii::json_escape(reason)))
|
||||
));
|
||||
}
|
||||
raii::string _typing(bool active, int timeout){
|
||||
return raii::string(
|
||||
rexy::string _typing(bool active, int timeout){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::typing(), active ? json::True() : json::False()),
|
||||
member(json::keys::timeout(), raii::itostr(timeout))
|
||||
));
|
||||
}
|
||||
raii::string _redact(const raii::string_base& reason){
|
||||
return raii::string(
|
||||
rexy::string _redact(const rexy::string_base& reason){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::reason(), quote(raii::json_escape(reason)))
|
||||
));
|
||||
}
|
||||
raii::string _room_upgrade(int version){
|
||||
return raii::string(
|
||||
rexy::string _room_upgrade(int version){
|
||||
return rexy::string(
|
||||
object(
|
||||
member(json::keys::newversion(), raii::itostr(version))
|
||||
));
|
||||
|
||||
@ -20,22 +20,22 @@
|
||||
|
||||
namespace matrix::sync{
|
||||
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),
|
||||
m_root(root.release()){}
|
||||
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");
|
||||
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>
|
||||
raii::rjp_string roomcxn_event_list_base<T>::start_token(void)&&{
|
||||
return raii::rjp_string(rjp_search_member(m_root.get(), "start"));
|
||||
}
|
||||
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");
|
||||
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>
|
||||
raii::rjp_string roomcxn_event_list_base<T>::end_token(void)&&{
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
*/
|
||||
|
||||
#include "matrix/rest/client_url_list.hpp"
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
#include "raii/util.hpp"
|
||||
|
||||
namespace matrix::rest{
|
||||
@ -25,41 +25,41 @@ namespace matrix::rest{
|
||||
client_url_list::client_url_list(const session_info& session){
|
||||
repopulate(session);
|
||||
}
|
||||
const raii::string& client_url_list::create_room(void)const{
|
||||
const rexy::string& client_url_list::create_room(void)const{
|
||||
return m_create_room;
|
||||
}
|
||||
const raii::string& client_url_list::file_upload(void)const{
|
||||
const rexy::string& client_url_list::file_upload(void)const{
|
||||
return m_file_upload;
|
||||
}
|
||||
const raii::string& client_url_list::room_list(void)const{
|
||||
const rexy::string& client_url_list::room_list(void)const{
|
||||
return m_room_list;
|
||||
}
|
||||
const raii::string& client_url_list::alias_lookup(void)const{
|
||||
const rexy::string& client_url_list::alias_lookup(void)const{
|
||||
return m_alias_lookup;
|
||||
}
|
||||
const raii::string& client_url_list::profile_picture(void)const{
|
||||
const rexy::string& client_url_list::profile_picture(void)const{
|
||||
return m_profile_picture;
|
||||
}
|
||||
raii::string client_url_list::displayname(const session_info& session, const raii::string_base& userid)const{
|
||||
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/profile/" + userid + "/displayname?access_token=" + session.access_token);
|
||||
rexy::string client_url_list::displayname(const session_info& session, const rexy::string_base& userid)const{
|
||||
return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/profile/" + userid + "/displayname?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string client_url_list::file_download(const session_info& session, const raii::string_base& fileurl){
|
||||
raii::string media = get_server_media_string(fileurl);
|
||||
rexy::string client_url_list::file_download(const session_info& session, const rexy::string_base& fileurl){
|
||||
rexy::string media = get_server_media_string(fileurl);
|
||||
if(!media) return {};
|
||||
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/download/" + media);
|
||||
return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/download/" + media);
|
||||
}
|
||||
raii::string client_url_list::file_thumbnail(const session_info& session, const raii::string_base& fileurl, int width, int height, const raii::string_base& method)const{
|
||||
raii::string media = get_server_media_string(fileurl);
|
||||
rexy::string client_url_list::file_thumbnail(const session_info& session, const rexy::string_base& fileurl, int width, int height, const rexy::string_base& method)const{
|
||||
rexy::string media = get_server_media_string(fileurl);
|
||||
if(!media) return {};
|
||||
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/thumbnail/" + media + "?width=" + raii::itostr(width) + "&height=" + raii::itostr(height) + "&method=" + method);
|
||||
return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/media/r0/thumbnail/" + media + "?width=" + raii::itostr(width) + "&height=" + raii::itostr(height) + "&method=" + method);
|
||||
}
|
||||
raii::string client_url_list::presence(const session_info& session, const raii::string_base& userid)const{
|
||||
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/presence/" + userid + "/status?access_token=" + session.access_token);
|
||||
rexy::string client_url_list::presence(const session_info& session, const rexy::string_base& userid)const{
|
||||
return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/presence/" + userid + "/status?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string client_url_list::sync(const session_info& session, const raii::rjp_string& next_batch, const raii::string& timeout){
|
||||
rexy::string client_url_list::sync(const session_info& session, const raii::rjp_string& next_batch, const rexy::string& timeout){
|
||||
if(!next_batch)
|
||||
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/sync?access_token=" + session.access_token + "&timeout=" + timeout);
|
||||
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/sync?access_token=" + session.access_token + "&timeout=" + timeout + "&since=" + next_batch);
|
||||
return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/sync?access_token=" + session.access_token + "&timeout=" + timeout);
|
||||
return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/sync?access_token=" + session.access_token + "&timeout=" + timeout + "&since=" + next_batch);
|
||||
}
|
||||
|
||||
void client_url_list::repopulate(const session_info& session){
|
||||
@ -77,11 +77,11 @@ namespace matrix::rest{
|
||||
m_alias_lookup.reset();
|
||||
}
|
||||
|
||||
raii::string client_url_list::get_server_media_string(const raii::string_base& url){
|
||||
rexy::string client_url_list::get_server_media_string(const rexy::string_base& url){
|
||||
if(!url || strncmp(url.get(), "mxc://", 6))
|
||||
return {};
|
||||
|
||||
return raii::string(url.get()+6, url.length()-6);
|
||||
return rexy::string(url.get()+6, url.length()-6);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -21,68 +21,68 @@
|
||||
|
||||
namespace matrix{
|
||||
|
||||
room_url_list::room_url_list(const session_info& session, const raii::string_base& roomid):
|
||||
room_url_list::room_url_list(const session_info& session, const rexy::string_base& roomid):
|
||||
m_typing(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/typing/" + session.userid + "?access_token=" + session.access_token),
|
||||
m_kick(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/kick?access_token=" + session.access_token),
|
||||
m_ban(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/ban?access_token=" + session.access_token),
|
||||
m_unban(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/unban?access_token=" + session.access_token),
|
||||
m_invite(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/invite?access_token=" + session.access_token),
|
||||
m_members(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/joined_members?access_token=" + session.access_token){}
|
||||
raii::string room_url_list::join(const session_info& session, const raii::string_base& roomid)const{
|
||||
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/leave?access_token=" + session.access_token);
|
||||
rexy::string room_url_list::join(const session_info& session, const rexy::string_base& roomid)const{
|
||||
return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/leave?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string room_url_list::leave(const session_info& session, const raii::string_base& roomid)const{
|
||||
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/join?access_token=" + session.access_token);
|
||||
rexy::string room_url_list::leave(const session_info& session, const rexy::string_base& roomid)const{
|
||||
return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/join?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string room_url_list::forget(const session_info& session, const raii::string_base& roomid)const{
|
||||
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/forget?access_token=" + session.access_token);
|
||||
rexy::string room_url_list::forget(const session_info& session, const rexy::string_base& roomid)const{
|
||||
return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/forget?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string room_url_list::upgrade(const session_info& session, const raii::string_base& roomid)const{
|
||||
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/upgrade?access_token=" + session.access_token);
|
||||
rexy::string room_url_list::upgrade(const session_info& session, const rexy::string_base& roomid)const{
|
||||
return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/upgrade?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string room_url_list::read_receipt(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const{
|
||||
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/receipt/m.read/" + eventid + "?access_token=" + session.access_token);
|
||||
rexy::string room_url_list::read_receipt(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const{
|
||||
return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/receipt/m.read/" + eventid + "?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string room_url_list::send(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventtype)const{
|
||||
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/send/" + eventtype + "?access_token=" + session.access_token);
|
||||
rexy::string room_url_list::send(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventtype)const{
|
||||
return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/send/" + eventtype + "?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string room_url_list::redact(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const{
|
||||
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/redact/" + eventid + "/0?access_token=" + session.access_token);
|
||||
rexy::string room_url_list::redact(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const{
|
||||
return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/redact/" + eventid + "/0?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string room_url_list::event(const session_info& session, const raii::string_base& roomid, const raii::string_base& eventid)const{
|
||||
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/event/" + eventid + "?access_token=" + session.access_token);
|
||||
rexy::string room_url_list::event(const session_info& session, const rexy::string_base& roomid, const rexy::string_base& eventid)const{
|
||||
return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/event/" + eventid + "?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string room_url_list::power_level(const session_info& session, const raii::string_base& roomid)const{
|
||||
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/state/m.room.power_levels?access_token=" + session.access_token);
|
||||
rexy::string room_url_list::power_level(const session_info& session, const rexy::string_base& roomid)const{
|
||||
return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/state/m.room.power_levels?access_token=" + session.access_token);
|
||||
}
|
||||
const raii::string& room_url_list::typing(void)const{
|
||||
const rexy::string& room_url_list::typing(void)const{
|
||||
return m_typing;
|
||||
}
|
||||
const raii::string& room_url_list::kick(void)const{
|
||||
const rexy::string& room_url_list::kick(void)const{
|
||||
return m_kick;
|
||||
}
|
||||
const raii::string& room_url_list::ban(void)const{
|
||||
const rexy::string& room_url_list::ban(void)const{
|
||||
return m_ban;
|
||||
}
|
||||
const raii::string& room_url_list::unban(void)const{
|
||||
const rexy::string& room_url_list::unban(void)const{
|
||||
return m_unban;
|
||||
}
|
||||
const raii::string& room_url_list::invite(void)const{
|
||||
const rexy::string& room_url_list::invite(void)const{
|
||||
return m_invite;
|
||||
}
|
||||
const raii::string& room_url_list::room_members(void)const{
|
||||
const rexy::string& room_url_list::room_members(void)const{
|
||||
return m_members;
|
||||
}
|
||||
raii::string room_url_list::messages(const session_info& session, const raii::string_base& roomid,
|
||||
const raii::string_base& from, const raii::string_base& to,
|
||||
const raii::string_base& dir, int limit)const
|
||||
rexy::string room_url_list::messages(const session_info& session, const rexy::string_base& roomid,
|
||||
const rexy::string_base& from, const rexy::string_base& to,
|
||||
const rexy::string_base& dir, int limit)const
|
||||
{
|
||||
if(to)
|
||||
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&to=" + to + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + session.access_token);
|
||||
return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&to=" + to + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + session.access_token);
|
||||
else
|
||||
return raii::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + session.access_token);
|
||||
return rexy::string(s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/messages?from=" + from + "&limit=" + raii::itostr(limit) + "&dir=" + dir + "&access_token=" + session.access_token);
|
||||
}
|
||||
void room_url_list::repopulate(const session_info& session, const raii::string_base& roomid){
|
||||
void room_url_list::repopulate(const session_info& session, const rexy::string_base& roomid){
|
||||
m_typing = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/typing/" + session.userid + "?access_token=" + session.access_token;
|
||||
m_kick = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/kick?access_token=" + session.access_token;
|
||||
m_ban = s_proto + session.homeserver + "/_matrix/client/r0/rooms/" + roomid + "/ban?access_token=" + session.access_token;
|
||||
|
||||
@ -19,16 +19,16 @@
|
||||
#include "matrix/rest/session_urls.hpp"
|
||||
|
||||
namespace matrix::rest::session_urls{
|
||||
raii::string login(const session_info& session){
|
||||
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/login");
|
||||
rexy::string login(const session_info& session){
|
||||
return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/login");
|
||||
}
|
||||
raii::string logout(const session_info& session){
|
||||
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/logout?access_token=" + session.access_token);
|
||||
rexy::string logout(const session_info& session){
|
||||
return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/logout?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string password(const session_info& session){
|
||||
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/account/password?access_token=" + session.access_token);
|
||||
rexy::string password(const session_info& session){
|
||||
return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/account/password?access_token=" + session.access_token);
|
||||
}
|
||||
raii::string whoami(const session_info& session){
|
||||
return raii::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/account/whoami?access_token=" + session.access_token);
|
||||
rexy::string whoami(const session_info& session){
|
||||
return rexy::string(matrix::rest::proto() + session.homeserver + "/_matrix/client/r0/account/whoami?access_token=" + session.access_token);
|
||||
}
|
||||
}
|
||||
|
||||
@ -17,7 +17,7 @@
|
||||
*/
|
||||
|
||||
#include "matrix/roomcxn.hpp"
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/string_base.hpp>
|
||||
#include "matrix/fat_strings.hpp"
|
||||
#include "matrix/json_targets.hpp"
|
||||
#include "raii/util.hpp"
|
||||
@ -26,23 +26,23 @@
|
||||
|
||||
namespace matrix{
|
||||
|
||||
roomcxn::roomcxn(const std::shared_ptr<session_info>& ses, const raii::string_base& roomid):
|
||||
roomcxn(ses, raii::string(roomid)){}
|
||||
roomcxn::roomcxn(const std::shared_ptr<session_info>& ses, raii::string&& roomid):
|
||||
roomcxn::roomcxn(const std::shared_ptr<session_info>& ses, const rexy::string_base& roomid):
|
||||
roomcxn(ses, rexy::string(roomid)){}
|
||||
roomcxn::roomcxn(const std::shared_ptr<session_info>& ses, rexy::string&& roomid):
|
||||
connection(ses),
|
||||
m_roomid(std::move(roomid)),
|
||||
m_urls(*ses, m_curl.encode(m_roomid)){}
|
||||
|
||||
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());
|
||||
}
|
||||
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());
|
||||
}
|
||||
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());
|
||||
}
|
||||
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>> retval;
|
||||
|
||||
raii::string resp = _get_curl(m_urls.room_members());
|
||||
rexy::string resp = _get_curl(m_urls.room_members());
|
||||
if(!resp) return _create_netreturn(resp, http_status());
|
||||
raii::rjp_ptr root(rjp_parse(resp.get()));
|
||||
if(!root) return _create_netreturn(root, http_status());
|
||||
@ -69,17 +69,17 @@ namespace matrix{
|
||||
}
|
||||
return retval;
|
||||
}
|
||||
netreturn<void> roomcxn::invite(const raii::string_base& userid){
|
||||
raii::string json(json::_userid(userid));
|
||||
netreturn<void> roomcxn::invite(const rexy::string_base& userid){
|
||||
rexy::string json(json::_userid(userid));
|
||||
printf("%s\n", json.get());
|
||||
raii::string response = _post_curl(json, m_urls.invite(), raii::curl_llist());
|
||||
rexy::string response = _post_curl(json, m_urls.invite(), raii::curl_llist());
|
||||
return _create_netreturn(response, http_status());
|
||||
}
|
||||
netreturn<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);
|
||||
}
|
||||
netreturn<void> roomcxn::kick(const raii::string_base& userid, const raii::string_base& reason){
|
||||
raii::string response;
|
||||
netreturn<void> roomcxn::kick(const rexy::string_base& userid, const rexy::string_base& reason){
|
||||
rexy::string response;
|
||||
if(reason){
|
||||
response = _post_curl(json::_userid_reason(userid, reason), m_urls.kick(), raii::curl_llist());
|
||||
}else{
|
||||
@ -87,8 +87,8 @@ namespace matrix{
|
||||
}
|
||||
return _create_netreturn(response, http_status());
|
||||
}
|
||||
netreturn<void> roomcxn::ban(const raii::string_base& userid, const raii::string_base& reason){
|
||||
raii::string response;
|
||||
netreturn<void> roomcxn::ban(const rexy::string_base& userid, const rexy::string_base& reason){
|
||||
rexy::string response;
|
||||
if(reason){
|
||||
response = _post_curl(json::_userid_reason(userid, reason), m_urls.ban(), raii::curl_llist());
|
||||
}else{
|
||||
@ -96,14 +96,14 @@ namespace matrix{
|
||||
}
|
||||
return _create_netreturn(response, http_status());
|
||||
}
|
||||
netreturn<void> roomcxn::unban(const raii::string_base& userid){
|
||||
raii::string response = _post_curl(json::_userid(userid), m_urls.unban(), raii::curl_llist());
|
||||
netreturn<void> roomcxn::unban(const rexy::string_base& userid){
|
||||
rexy::string response = _post_curl(json::_userid(userid), m_urls.unban(), raii::curl_llist());
|
||||
return _create_netreturn(response, http_status());
|
||||
}
|
||||
|
||||
|
||||
netreturn<raii::rjp_string> roomcxn::send_custom_event(const raii::string_base& event, const raii::string_base& eventtype)const{
|
||||
raii::string reply = _post_curl(event, m_urls.send(*m_ses, m_curl.encode(m_roomid), eventtype), raii::curl_llist());
|
||||
netreturn<raii::rjp_string> roomcxn::send_custom_event(const rexy::string_base& event, const rexy::string_base& eventtype)const{
|
||||
rexy::string reply = _post_curl(event, m_urls.send(*m_ses, m_curl.encode(m_roomid), eventtype), raii::curl_llist());
|
||||
if(!reply)
|
||||
return _create_netreturn(reply, http_status());
|
||||
|
||||
@ -112,10 +112,10 @@ namespace matrix{
|
||||
retval.value() = _curl_reply_search(root, json::keys::event::eventid());
|
||||
return retval;
|
||||
}
|
||||
netreturn<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));
|
||||
}
|
||||
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));
|
||||
}
|
||||
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{
|
||||
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{
|
||||
return _create_netreturn(_post_curl(raii::string(), m_urls.read_receipt(*m_ses, m_curl.encode(m_roomid), m_curl.encode(eventid)), raii::curl_llist()), http_status());
|
||||
netreturn<void> roomcxn::send_read_receipt(const rexy::string_base& eventid)const{
|
||||
return _create_netreturn(_post_curl(rexy::string(), m_urls.read_receipt(*m_ses, m_curl.encode(m_roomid), m_curl.encode(eventid)), raii::curl_llist()), http_status());
|
||||
}
|
||||
|
||||
netreturn<sync::roomcxn_message_event_list> roomcxn::get_event(const raii::string_base& eventid)const{
|
||||
raii::string reply = _get_curl(m_urls.event(*m_ses, m_curl.encode(m_roomid), eventid));
|
||||
netreturn<sync::roomcxn_message_event_list> roomcxn::get_event(const rexy::string_base& eventid)const{
|
||||
rexy::string reply = _get_curl(m_urls.event(*m_ses, m_curl.encode(m_roomid), eventid));
|
||||
if(!reply) return _create_netreturn(reply, http_status());
|
||||
raii::rjp_ptr root(rjp_parse(reply.get()));
|
||||
if(!root.get()) _create_netreturn(root, http_status());
|
||||
@ -151,14 +151,14 @@ namespace matrix{
|
||||
retval.value() = sync::roomcxn_message_event_list(root, root.get(), m_roomid);
|
||||
return retval;
|
||||
}
|
||||
netreturn<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());
|
||||
}
|
||||
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);
|
||||
}
|
||||
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){
|
||||
raii::string reply = _get_curl(m_urls.messages(*m_ses, m_curl.encode(m_roomid), from, to, direction, amount));
|
||||
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){
|
||||
rexy::string reply = _get_curl(m_urls.messages(*m_ses, m_curl.encode(m_roomid), from, to, direction, amount));
|
||||
if(!reply) return _create_netreturn(reply, http_status());
|
||||
raii::rjp_ptr root(rjp_parse(reply.get()));
|
||||
if(!root.get()) _create_netreturn(root, http_status());
|
||||
@ -171,15 +171,15 @@ namespace matrix{
|
||||
return retval;
|
||||
}
|
||||
netreturn<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){
|
||||
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);
|
||||
}
|
||||
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);
|
||||
}
|
||||
|
||||
@ -190,7 +190,7 @@ namespace matrix{
|
||||
return _post_and_find(json::_room_upgrade(version), m_urls.upgrade(*m_ses, m_roomid), raii::curl_llist(), json::keys::event::eventid());
|
||||
}
|
||||
|
||||
netreturn<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);
|
||||
}
|
||||
}
|
||||
|
||||
@ -20,15 +20,15 @@
|
||||
#include "raii/rjp_ptr.hpp"
|
||||
#include "raii/curler.hpp"
|
||||
#include "raii/util.hpp"
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/string_base.hpp>
|
||||
#include "matrix/fat_strings.hpp"
|
||||
#include "matrix/json_targets.hpp"
|
||||
#include "matrix/rest/session_urls.hpp"
|
||||
|
||||
namespace matrix{
|
||||
|
||||
static raii::string create_auth_header(const raii::string_base& token){
|
||||
return raii::string("Authorization: Bearer " + token);
|
||||
static rexy::string create_auth_header(const rexy::string_base& token){
|
||||
return rexy::string("Authorization: Bearer " + token);
|
||||
}
|
||||
|
||||
session::session(void):
|
||||
@ -43,43 +43,43 @@ namespace matrix{
|
||||
invalidate();
|
||||
}
|
||||
|
||||
void session::set_useragent(const raii::string_base& agent){
|
||||
void session::set_useragent(const rexy::string_base& agent){
|
||||
m_ses->useragent = agent;
|
||||
}
|
||||
void session::set_useragent(raii::string&& agent){
|
||||
void session::set_useragent(rexy::string&& agent){
|
||||
m_ses->useragent = std::move(agent);
|
||||
}
|
||||
void session::set_homeserver(const raii::string_base& hs){
|
||||
void session::set_homeserver(const rexy::string_base& hs){
|
||||
m_ses->homeserver = hs;
|
||||
}
|
||||
void session::set_homeserver(raii::string&& hs){
|
||||
void session::set_homeserver(rexy::string&& hs){
|
||||
m_ses->homeserver = std::move(hs);
|
||||
}
|
||||
void session::set_access_token(const raii::string_base& tok){
|
||||
void session::set_access_token(const rexy::string_base& tok){
|
||||
m_ses->access_token = tok;
|
||||
m_ses->auth_header = create_auth_header(m_ses->access_token);
|
||||
}
|
||||
void session::set_access_token(raii::string&& tok){
|
||||
void session::set_access_token(rexy::string&& tok){
|
||||
m_ses->access_token = std::move(tok);
|
||||
m_ses->auth_header = create_auth_header(m_ses->access_token);
|
||||
}
|
||||
|
||||
netreturn<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);
|
||||
}
|
||||
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());
|
||||
}
|
||||
|
||||
bool session::valid(void)const{
|
||||
return m_valid;
|
||||
}
|
||||
netreturn<void> session::change_password(const raii::string_base& oldpass, const raii::string_base& newpass){
|
||||
raii::string reply = _post_curl(json::_empty(), rest::session_urls::password(*m_ses), raii::curl_llist());
|
||||
netreturn<void> session::change_password(const rexy::string_base& oldpass, const rexy::string_base& newpass){
|
||||
rexy::string reply = _post_curl(json::_empty(), rest::session_urls::password(*m_ses), raii::curl_llist());
|
||||
if(!reply)
|
||||
return _create_netreturn(reply, http_status());
|
||||
raii::rjp_ptr root(rjp_parse(reply));
|
||||
@ -89,7 +89,7 @@ namespace matrix{
|
||||
|
||||
//attempt to change password via username/password login
|
||||
RJP_value* res = rjp_search_member(root.get(), json::keys::session());
|
||||
raii::string request = json::_change_psk_password(m_ses->userid, newpass, oldpass, raii::rjp_string(res));
|
||||
rexy::string request = json::_change_psk_password(m_ses->userid, newpass, oldpass, raii::rjp_string(res));
|
||||
reply = _post_curl(request, rest::session_urls::password(*m_ses), raii::curl_llist());
|
||||
return _create_netreturn(reply, http_status());
|
||||
}
|
||||
@ -104,7 +104,7 @@ namespace matrix{
|
||||
m_ses->userid.reset();
|
||||
}
|
||||
|
||||
netreturn<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));
|
||||
netreturn<void> retval = _create_netreturn(reply, http_status());
|
||||
if(!retval.ok()){
|
||||
@ -143,16 +143,16 @@ namespace matrix{
|
||||
m_ses->auth_header = create_auth_header(m_ses->access_token);
|
||||
_do_login(a.name, a.pass);
|
||||
}
|
||||
raii::string session::_request_access_token(const raii::string_base& name, const raii::string_base& pass, const raii::string_base& loginurl)const{
|
||||
raii::string postdata = json::_login_password(name, pass);
|
||||
raii::string reply = _post_curl(postdata, loginurl, raii::curl_llist{});
|
||||
rexy::string session::_request_access_token(const rexy::string_base& name, const rexy::string_base& pass, const rexy::string_base& loginurl)const{
|
||||
rexy::string postdata = json::_login_password(name, pass);
|
||||
rexy::string reply = _post_curl(postdata, loginurl, raii::curl_llist{});
|
||||
return reply;
|
||||
}
|
||||
netreturn<raii::rjp_string> session::_get_userid(void){
|
||||
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){
|
||||
raii::string reply = _request_access_token(name, pass, 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){
|
||||
rexy::string reply = _request_access_token(name, pass, loginurl);
|
||||
if(!reply)
|
||||
return _create_netreturn(reply, http_status());
|
||||
raii::rjp_ptr root(rjp_parse(reply));
|
||||
|
||||
@ -21,8 +21,8 @@
|
||||
namespace matrix::sync{
|
||||
|
||||
//Room event response
|
||||
raii::static_string room_event_response::roomid(void)const{
|
||||
return raii::static_string(rjp_member_key(m_room)->value, rjp_member_key(m_room)->length);
|
||||
rexy::static_string room_event_response::roomid(void)const{
|
||||
return rexy::static_string(rjp_member_key(m_room)->value, rjp_member_key(m_room)->length);
|
||||
}
|
||||
RJP_value* room_event_response::_find_event_list(const char* mname)const{
|
||||
RJP_value* res = rjp_search_member(m_room, mname);
|
||||
@ -50,7 +50,7 @@ namespace matrix::sync{
|
||||
}
|
||||
|
||||
//Sync response
|
||||
client_response::client_response(const raii::string_base& s):
|
||||
client_response::client_response(const rexy::string_base& s):
|
||||
m_root(rjp_parse(s)){}
|
||||
client_response::client_response(RJP_value* root):
|
||||
m_root(root){}
|
||||
@ -66,10 +66,10 @@ namespace matrix::sync{
|
||||
device_list client_response::device_lists(void)const{
|
||||
return rjp_search_member(m_root.get(), "device_lists");
|
||||
}
|
||||
raii::static_string client_response::next_batch(void)const&{
|
||||
rexy::static_string client_response::next_batch(void)const&{
|
||||
RJP_value* nb = rjp_search_member(m_root.get(), "next_batch");
|
||||
if(!nb) return {};
|
||||
return raii::static_string(rjp_get_cstring(nb)->value, rjp_get_cstring(nb)->length);
|
||||
return rexy::static_string(rjp_get_cstring(nb)->value, rjp_get_cstring(nb)->length);
|
||||
}
|
||||
raii::rjp_string client_response::next_batch(void)&&{
|
||||
return raii::rjp_string(rjp_search_member(m_root.get(), "next_batch"));
|
||||
|
||||
@ -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];
|
||||
}
|
||||
}
|
||||
@ -62,19 +62,19 @@ namespace raii{
|
||||
curler& curler::seturl(const char* s){
|
||||
return setopt(CURLOPT_URL, s);
|
||||
}
|
||||
curler& curler::seturl(const string_base& s){
|
||||
curler& curler::seturl(const rexy::string_base& s){
|
||||
return seturl(s.get());
|
||||
}
|
||||
curler& curler::setuseragent(const char* s){
|
||||
return setopt(CURLOPT_USERAGENT, s);
|
||||
}
|
||||
curler& curler::setuseragent(const string_base& s){
|
||||
curler& curler::setuseragent(const rexy::string_base& s){
|
||||
return setuseragent(s.get());
|
||||
}
|
||||
curler& curler::setuserpwd(const char* s){
|
||||
return setopt(CURLOPT_USERPWD, s);
|
||||
}
|
||||
curler& curler::setuserpwd(const string_base& s){
|
||||
curler& curler::setuserpwd(const rexy::string_base& s){
|
||||
return setuserpwd(s.get());
|
||||
}
|
||||
curler& curler::setpostdata(const char* s, curl_off_t len){
|
||||
@ -82,7 +82,7 @@ namespace raii{
|
||||
setopt(CURLOPT_POSTFIELDSIZE_LARGE, len);
|
||||
return *this;
|
||||
}
|
||||
curler& curler::setpostdata(const string_base& s){
|
||||
curler& curler::setpostdata(const rexy::string_base& s){
|
||||
setpostdata(s.get(), s.length());
|
||||
return *this;
|
||||
}
|
||||
|
||||
@ -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());
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@ -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;
|
||||
}
|
||||
|
||||
}
|
||||
@ -16,7 +16,7 @@
|
||||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "raii/string.hpp"
|
||||
#include <rexy/string.hpp>
|
||||
|
||||
namespace raii{
|
||||
|
||||
@ -82,12 +82,12 @@ namespace raii{
|
||||
return pos;
|
||||
}
|
||||
}
|
||||
string json_escape(const string_base& str){
|
||||
rexy::string json_escape(const rexy::string_base& str){
|
||||
size_t len = detail::_calc_escaped_len(str.get());
|
||||
char* tmp = reinterpret_cast<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);
|
||||
tmp[len] = 0;
|
||||
return string(tmp, len, len);
|
||||
return rexy::string(tmp, len, len);
|
||||
}
|
||||
|
||||
|
||||
@ -112,11 +112,11 @@ namespace raii{
|
||||
}
|
||||
}
|
||||
}
|
||||
raii::string itostr(int i){
|
||||
rexy::string itostr(int i){
|
||||
if(i == 0)
|
||||
return raii::string("0");
|
||||
return rexy::string("0");
|
||||
int place = intlen(i);
|
||||
raii::string ret(place, place);
|
||||
rexy::string ret(place, place);
|
||||
char* buf = ret.get();
|
||||
buf[place] = 0;
|
||||
while(i != 0){
|
||||
|
||||
35
src/test.cpp
35
src/test.cpp
@ -19,11 +19,12 @@
|
||||
//example of a client which responds to commands
|
||||
|
||||
#include "matrix/matrix.hpp"
|
||||
#include "raii/string_base.hpp"
|
||||
#include <rexy/string_base.hpp>
|
||||
#include "matrix/sync_response.hpp"
|
||||
#include "raii/util.hpp"
|
||||
#include "matrix/json_targets.hpp"
|
||||
#include "matrix/events.hpp"
|
||||
#include <rexy/filerd.hpp>
|
||||
|
||||
#include <atomic>
|
||||
#include <thread>
|
||||
@ -32,7 +33,7 @@
|
||||
#include <cctype>
|
||||
|
||||
matrix::auth_data read_auth_file(const char* filename){
|
||||
raii::filerd fp(filename, "r");
|
||||
rexy::filerd fp(filename, "r");
|
||||
if(!fp){
|
||||
return {};
|
||||
}
|
||||
@ -61,7 +62,7 @@ void write_to_auth_file(const char* filename, const matrix::auth_data& auth){
|
||||
raii::rjp_string output;
|
||||
output.reset(rjp_to_json(root.get(), RJP_FORMAT_NONE));
|
||||
|
||||
raii::filerd fp(filename, "w");
|
||||
rexy::filerd fp(filename, "w");
|
||||
if(!fp)
|
||||
return;
|
||||
fp.write(output);
|
||||
@ -85,7 +86,7 @@ matrix::session login_to_homeserver(void){
|
||||
}
|
||||
|
||||
struct command{
|
||||
raii::static_string command_name;
|
||||
rexy::static_string command_name;
|
||||
void(*command_exec)(const matrix::client&, const matrix::roomcxn&, const matrix::sync::room_message_event&);
|
||||
};
|
||||
|
||||
@ -123,8 +124,8 @@ void do_help(const matrix::client&, const matrix::roomcxn& room, const matrix::s
|
||||
}
|
||||
void do_gaben(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event& event){
|
||||
if(event.body().length() > 6){
|
||||
raii::static_string args = event.body().get() + 7;
|
||||
room.send_message(raii::string(args + " can suck my ass"_ss));
|
||||
rexy::static_string args = event.body().get() + 7;
|
||||
room.send_message(rexy::string(args + " can suck my ass"_ss));
|
||||
}else{
|
||||
room.send_notice("can suck my ass"_ss);
|
||||
}
|
||||
@ -139,11 +140,11 @@ void do_emacs(const matrix::client&, const matrix::roomcxn& room, const matrix::
|
||||
room.send_notice("Unfortunately, the matrix spec has no official way to forward messages. As such, riot will not interpret me sending custom forwarded events correctly. Will update when it is in the spec."_ss);
|
||||
}
|
||||
void do_nipple(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event&){
|
||||
raii::static_string str = R"({"msgtype":"m.image","body":"image.jpeg","url":"mxc://rexy712.chickenkiller.com/tmvjkYZYuhfjtMpfQcurSakd","info":{"mimetype":"image/jpeg","size":40202,"h":402,"w":512,"orientation":0}})"_ss;
|
||||
rexy::static_string str = R"({"msgtype":"m.image","body":"image.jpeg","url":"mxc://rexy712.chickenkiller.com/tmvjkYZYuhfjtMpfQcurSakd","info":{"mimetype":"image/jpeg","size":40202,"h":402,"w":512,"orientation":0}})"_ss;
|
||||
room.send_custom_event(str, "m.room.message"_ss);
|
||||
}
|
||||
raii::string get_command_output(const raii::string_base& command){
|
||||
raii::string result;
|
||||
rexy::string get_command_output(const rexy::string_base& command){
|
||||
rexy::string result;
|
||||
FILE* pipe = popen(command.get(), "r");
|
||||
if(!pipe)
|
||||
return {};
|
||||
@ -157,11 +158,11 @@ raii::string get_command_output(const raii::string_base& command){
|
||||
}
|
||||
|
||||
void do_ddate(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event& event){
|
||||
raii::string str = get_command_output(raii::static_string(event.body().get()+1));
|
||||
rexy::string str = get_command_output(rexy::static_string(event.body().get()+1));
|
||||
room.send_notice(str);
|
||||
}
|
||||
|
||||
int roll_func(const raii::string_base& args, int& returnval){
|
||||
int roll_func(const rexy::string_base& args, int& returnval){
|
||||
int state = 0;
|
||||
int diecount = 1;
|
||||
int sidecount = 100;
|
||||
@ -239,7 +240,7 @@ int roll_func(const raii::string_base& args, int& returnval){
|
||||
void do_roll(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event& event){
|
||||
int rollval;
|
||||
if(event.body().length() > 5){
|
||||
if(roll_func(raii::static_string(event.body().get()+6), rollval))
|
||||
if(roll_func(rexy::static_string(event.body().get()+6), rollval))
|
||||
return;
|
||||
}else{
|
||||
if(roll_func(""_ss, rollval))
|
||||
@ -253,7 +254,7 @@ void do_test(const matrix::client&, const matrix::roomcxn& room, const matrix::s
|
||||
}
|
||||
|
||||
void do_weebrules(const matrix::client&, const matrix::roomcxn& room, const matrix::sync::room_message_event&){
|
||||
raii::static_string rules =
|
||||
rexy::static_string rules =
|
||||
"1.) Can't exclude without watching >=2 episodes\n"
|
||||
"2.) Have to respect the role unless\n a.) it's not anime night\n b.) already seen >=3 episodes\n"
|
||||
"3.) r0nk complaining shall be redirected into /dev/null\n"
|
||||
@ -273,7 +274,7 @@ void do_cyberpunk(const matrix::client&, const matrix::roomcxn& room, const matr
|
||||
void do_sauce(const matrix::client& client, const matrix::roomcxn& room, const matrix::sync::room_message_event&){
|
||||
matrix::file_details fd;
|
||||
fd.name = "src/test.cpp"_ss;
|
||||
raii::filerd fp(fd.name);
|
||||
rexy::filerd fp(fd.name);
|
||||
if(!fp){
|
||||
printf("fopen error\n");
|
||||
return;
|
||||
@ -322,12 +323,12 @@ void handle_command(const matrix::client& client, const matrix::roomcxn& room, c
|
||||
}
|
||||
}
|
||||
|
||||
raii::string get_showinfo(const raii::string_base& file, const raii::string_base& show){
|
||||
raii::filerd fp(file);
|
||||
rexy::string get_showinfo(const rexy::string_base& file, const rexy::string_base& show){
|
||||
rexy::filerd fp(file);
|
||||
if(!fp)
|
||||
return {};
|
||||
|
||||
raii::string line;
|
||||
rexy::string line;
|
||||
for(line = fp.readln();line.length();line = fp.readln()){
|
||||
if(!strncmp(line, show, show.length()) && line[show.length()] == ':')
|
||||
return line;
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user