gergely/matrix-glib-sdk
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Rename MatrixAPIFilterRules to MatrixFilterRules

Browse Source
This commit is contained in:
Gergely Polonkai 2016-01-25 13:03:26 +01:00
parent e163e73f2c
commit 7ab4e556bd
3 changed files with 268 additions and 282 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

68
docs/reference/matrix-glib/matrix-glib-sections.txt
View File

@ -38,38 +38,38 @@ MatrixReceiptType
MatrixAccountKind MatrixAccountKind
<SUBSECTION> <SUBSECTION>
MatrixAPIFilterRules MatrixFilterRules
matrix_api_filter_rules_new matrix_filter_rules_new
matrix_api_filter_rules_ref matrix_filter_rules_ref
matrix_api_filter_rules_unref matrix_filter_rules_unref
matrix_api_filter_rules_set_limit matrix_filter_rules_set_limit
matrix_api_filter_rules_get_limit matrix_filter_rules_get_limit
matrix_api_filter_rules_set_rooms matrix_filter_rules_set_rooms
matrix_api_filter_rules_add_room matrix_filter_rules_add_room
matrix_api_filter_rules_delete_room matrix_filter_rules_delete_room
matrix_api_filter_rules_get_rooms matrix_filter_rules_get_rooms
matrix_api_filter_rules_set_excluded_rooms matrix_filter_rules_set_excluded_rooms
matrix_api_filter_rules_add_excluded_room matrix_filter_rules_add_excluded_room
matrix_api_filter_rules_delete_excluded_room matrix_filter_rules_delete_excluded_room
matrix_api_filter_rules_get_excluded_rooms matrix_filter_rules_get_excluded_rooms
matrix_api_filter_rules_set_senders matrix_filter_rules_set_senders
matrix_api_filter_rules_add_sender matrix_filter_rules_add_sender
matrix_api_filter_rules_delete_sender matrix_filter_rules_delete_sender
matrix_api_filter_rules_get_senders matrix_filter_rules_get_senders
matrix_api_filter_rules_set_excluded_senders matrix_filter_rules_set_excluded_senders
matrix_api_filter_rules_add_excluded_sender matrix_filter_rules_add_excluded_sender
matrix_api_filter_rules_delete_excluded_sender matrix_filter_rules_delete_excluded_sender
matrix_api_filter_rules_get_excluded_senders matrix_filter_rules_get_excluded_senders
matrix_api_filter_rules_set_types matrix_filter_rules_set_types
matrix_api_filter_rules_add_type matrix_filter_rules_add_type
matrix_api_filter_rules_delete_type matrix_filter_rules_delete_type
matrix_api_filter_rules_get_types matrix_filter_rules_get_types
matrix_api_filter_rules_set_excluded_types matrix_filter_rules_set_excluded_types
matrix_api_filter_rules_add_excluded_type matrix_filter_rules_add_excluded_type
matrix_api_filter_rules_delete_excluded_type matrix_filter_rules_delete_excluded_type
matrix_api_filter_rules_get_excluded_types matrix_filter_rules_get_excluded_types
matrix_api_filter_rules_get_json_node matrix_filter_rules_get_json_node
matrix_api_filter_rules_get_json_data matrix_filter_rules_get_json_data
<SUBSECTION> <SUBSECTION>
MatrixAPIRoomFilter MatrixAPIRoomFilter
@ -181,8 +181,8 @@ MATRIX_TYPE_RECEIPT_TYPE
matrix_receipt_type_get_type matrix_receipt_type_get_type
MATRIX_TYPE_ACCOUNT_KIND MATRIX_TYPE_ACCOUNT_KIND
matrix_account_kind_get_type matrix_account_kind_get_type
MATRIX_TYPE_API_FILTER_RULES MATRIX_TYPE_FILTER_RULES
matrix_api_filter_rules_get_type matrix_filter_rules_get_type
MATRIX_TYPE_API_ROOM_FILTER MATRIX_TYPE_API_ROOM_FILTER
matrix_api_room_filter_get_type matrix_api_room_filter_get_type
MATRIX_TYPE_API_FILTER MATRIX_TYPE_API_FILTER

364
src/matrix-types.c
View File

@ -230,14 +230,14 @@ G_DEFINE_QUARK(matrix-error-quark, matrix_error);
*/ */
/** /**
* MatrixAPIFilterRules: (ref-func matrix_api_filter_rules_ref) (unref-func matrix_api_filter_rules_unref) * MatrixFilterRules: (ref-func matrix_filter_rules_ref) (unref-func matrix_filter_rules_unref)
* *
* An opaque structure to hold filter rules that can be used to filter * An opaque structure to hold filter rules that can be used to filter
* events in the event stream. It is possible to filter by event type, * events in the event stream. It is possible to filter by event type,
* room and sender ID. * room and sender ID.
*/ */
struct _MatrixAPIFilterRules { struct _MatrixFilterRules {
guint limit; guint limit;
GList *rooms; GList *rooms;
GList *excluded_rooms; GList *excluded_rooms;
@ -248,31 +248,31 @@ struct _MatrixAPIFilterRules {
guint refcount; guint refcount;
}; };
G_DEFINE_BOXED_TYPE(MatrixAPIFilterRules, matrix_api_filter_rules, G_DEFINE_BOXED_TYPE(MatrixFilterRules, matrix_filter_rules,
(GBoxedCopyFunc)matrix_api_filter_rules_ref, (GBoxedCopyFunc)matrix_filter_rules_ref,
(GBoxedFreeFunc)matrix_api_filter_rules_unref); (GBoxedFreeFunc)matrix_filter_rules_unref);
/** /**
* matrix_api_filter_rules_new: * matrix_filter_rules_new:
* *
* Create a new #MatrixAPIFilterRules object with reference count of * Create a new #MatrixFilterRules object with reference count of
* 1. * 1.
* *
* Returns: (transfer full): a new #MatrixAPIFilterRules * Returns: (transfer full): a new #MatrixFilterRules
*/ */
MatrixAPIFilterRules * MatrixFilterRules *
matrix_api_filter_rules_new(void) matrix_filter_rules_new(void)
{ {
MatrixAPIFilterRules *rules; MatrixFilterRules *rules;
rules = g_new0(MatrixAPIFilterRules, 1); rules = g_new0(MatrixFilterRules, 1);
rules->refcount = 1; rules->refcount = 1;
return rules; return rules;
} }
static void static void
matrix_api_filter_rules_free(MatrixAPIFilterRules *rules) matrix_filter_rules_free(MatrixFilterRules *rules)
{ {
g_list_free_full(rules->rooms, g_free); g_list_free_full(rules->rooms, g_free);
g_list_free_full(rules->excluded_rooms, g_free); g_list_free_full(rules->excluded_rooms, g_free);
@ -285,15 +285,15 @@ matrix_api_filter_rules_free(MatrixAPIFilterRules *rules)
} }
/** /**
* matrix_api_filter_rules_ref: * matrix_filter_rules_ref:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* *
* Increase reference count of @rules by one. * Increase reference count of @rules by one.
* *
* Returns: (transfer none): the same #MatrixAPIFilterRules * Returns: (transfer none): the same #MatrixFilterRules
*/ */
MatrixAPIFilterRules * MatrixFilterRules *
matrix_api_filter_rules_ref(MatrixAPIFilterRules *rules) matrix_filter_rules_ref(MatrixFilterRules *rules)
{ {
rules->refcount++; rules->refcount++;
@ -301,56 +301,56 @@ matrix_api_filter_rules_ref(MatrixAPIFilterRules *rules)
} }
/** /**
* matrix_api_filter_rules_unref: * matrix_filter_rules_unref:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* *
* Decrease reference count of @rules by one. If reference count * Decrease reference count of @rules by one. If reference count
* reaches zero, @rules is freed. * reaches zero, @rules is freed.
*/ */
void void
matrix_api_filter_rules_unref(MatrixAPIFilterRules *rules) matrix_filter_rules_unref(MatrixFilterRules *rules)
{ {
if (--rules->refcount == 0) { if (--rules->refcount == 0) {
matrix_api_filter_rules_free(rules); matrix_filter_rules_free(rules);
} }
} }
/** /**
* matrix_api_filter_rules_set_limit: * matrix_filter_rules_set_limit:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @limit: (in): the maximum number of events to return. * @limit: (in): the maximum number of events to return.
* *
* Set the maximum number of events to return by the filter. If @limit * Set the maximum number of events to return by the filter. If @limit
* is <code>0</code>, no limit will be applied. * is <code>0</code>, no limit will be applied.
*/ */
void void
matrix_api_filter_rules_set_limit(MatrixAPIFilterRules *rules, guint limit) matrix_filter_rules_set_limit(MatrixFilterRules *rules, guint limit)
{ {
rules->limit = limit; rules->limit = limit;
} }
/** /**
* matrix_api_filter_rules_get_limit: * matrix_filter_rules_get_limit:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* *
* Get the current limit set in @rules. * Get the current limit set in @rules.
* *
* Returns: the limit currently set * Returns: the limit currently set
*/ */
guint guint
matrix_api_filter_rules_get_limit(MatrixAPIFilterRules *rules) matrix_filter_rules_get_limit(MatrixFilterRules *rules)
{ {
return rules->limit; return rules->limit;
} }
/** /**
* matrix_api_filter_rules_set_senders: * matrix_filter_rules_set_senders:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @senders: (in) (element-type utf8) (transfer full) (allow-none): * @senders: (in) (element-type utf8) (transfer full) (allow-none):
* a list of Matrix user IDs. Events from these users will * a list of Matrix user IDs. Events from these users will
* be included in the filtered event list.If %NULL then all * be included in the filtered event list.If %NULL then all
* senders are included. See * senders are included. See
* matrix_api_filter_rules_add_sender() for wildcarding * matrix_filter_rules_add_sender() for wildcarding
* possibilities * possibilities
* *
* Set the list of user IDs to include in the filtered events. @rules * Set the list of user IDs to include in the filtered events. @rules
@ -358,15 +358,15 @@ matrix_api_filter_rules_get_limit(MatrixAPIFilterRules *rules)
* directly after this call. * directly after this call.
*/ */
void void
matrix_api_filter_rules_set_senders(MatrixAPIFilterRules *rules, GList *senders) matrix_filter_rules_set_senders(MatrixFilterRules *rules, GList *senders)
{ {
g_list_free_full(rules->senders, g_free); g_list_free_full(rules->senders, g_free);
rules->senders = senders; rules->senders = senders;
} }
/** /**
* matrix_api_filter_rules_add_sender: * matrix_filter_rules_add_sender:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @sender: (in): a Matrix user ID to add to the included senders * @sender: (in): a Matrix user ID to add to the included senders
* list. A <code>*</code> can be used as a wildcard to match * list. A <code>*</code> can be used as a wildcard to match
* any sequence of characters * any sequence of characters
@ -376,8 +376,7 @@ matrix_api_filter_rules_set_senders(MatrixAPIFilterRules *rules, GList *senders)
* nothing happens. * nothing happens.
*/ */
void void
matrix_api_filter_rules_add_sender(MatrixAPIFilterRules *rules, matrix_filter_rules_add_sender(MatrixFilterRules *rules, const gchar *sender)
const gchar *sender)
{ {
g_return_if_fail(sender != NULL); g_return_if_fail(sender != NULL);
@ -387,16 +386,15 @@ matrix_api_filter_rules_add_sender(MatrixAPIFilterRules *rules,
} }
/** /**
* matrix_api_filter_rules_delete_sender: * matrix_filter_rules_delete_sender:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @sender: (in): the user ID to remove from the senders list * @sender: (in): the user ID to remove from the senders list
* *
* Remove @sender from the list of user IDs to include in the filtered * Remove @sender from the list of user IDs to include in the filtered
* event list. * event list.
*/ */
void void
matrix_api_filter_rules_delete_sender(MatrixAPIFilterRules *rules, matrix_filter_rules_delete_sender(MatrixFilterRules *rules, const gchar *sender)
const gchar *sender)
{ {
GList *sender_element; GList *sender_element;
@ -410,8 +408,8 @@ matrix_api_filter_rules_delete_sender(MatrixAPIFilterRules *rules,
} }
/** /**
* matrix_api_filter_rules_get_senders: * matrix_filter_rules_get_senders:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* *
* Get the list of user IDs that will be included in the filtered * Get the list of user IDs that will be included in the filtered
* events. * events.
@ -421,50 +419,50 @@ matrix_api_filter_rules_delete_sender(MatrixAPIFilterRules *rules,
* and should not be freed nor modified * and should not be freed nor modified
*/ */
const GList * const GList *
matrix_api_filter_rules_get_senders(MatrixAPIFilterRules *rules) matrix_filter_rules_get_senders(MatrixFilterRules *rules)
{ {
return rules->senders; return rules->senders;
} }
/** /**
* matrix_api_filter_rules_set_excluded_senders: * matrix_filter_rules_set_excluded_senders:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @senders: (in) (element-type utf8) (transfer full) (allow-none): * @senders: (in) (element-type utf8) (transfer full) (allow-none): a
* a list of Matrix user IDs. Events from these users will * list of Matrix user IDs. Events from these users will be
* be included in the filtered event list.If %NULL then all * included in the filtered event list.If %NULL then all
* senders are included. See * senders are included. See
* matrix_api_filter_rules_add_sender() for wildcarding * matrix_filter_rules_add_sender() for wildcarding
* possibilities * possibilities
* *
* Set the list of Matrix user IDs to exclude from the filtered * Set the list of Matrix user IDs to exclude from the filtered
* events. A matching sender will be excluded even if it is listed in * events. A matching sender will be excluded even if it is listed in
* the senders list (specified by * the senders list (specified by
* e.g. matrix_api_filter_rules_set_senders()). @rules takes * e.g. matrix_filter_rules_set_senders()). @rules takes ownership of
* ownership of @senders, so it should not be freed nor modified * @senders, so it should not be freed nor modified directly after
* directly after this call. * this call.
*/ */
void void
matrix_api_filter_rules_set_excluded_senders(MatrixAPIFilterRules *rules, matrix_filter_rules_set_excluded_senders(MatrixFilterRules *rules,
GList *senders) GList *senders)
{ {
g_list_free_full(rules->excluded_senders, g_free); g_list_free_full(rules->excluded_senders, g_free);
rules->excluded_senders = senders; rules->excluded_senders = senders;
} }
/** /**
* matrix_api_filter_rules_add_excluded_sender: * matrix_filter_rules_add_excluded_sender:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @sender: (in): a Matrix user ID to add to the excluded senders * @sender: (in): a Matrix user ID to add to the excluded senders
* list. See matrix_api_filter_rules_add_sender() for * list. See matrix_filter_rules_add_sender() for wildcarding
* wildcarding possibilities * possibilities
* *
* Add @sender to the list of user IDs to exclude from the filtered * Add @sender to the list of user IDs to exclude from the filtered
* event list. If @sender is already in the excluded senders list, * event list. If @sender is already in the excluded senders list,
* nothing happens. * nothing happens.
*/ */
void void
matrix_api_filter_rules_add_excluded_sender(MatrixAPIFilterRules *rules, matrix_filter_rules_add_excluded_sender(MatrixFilterRules *rules,
const gchar *sender) const gchar *sender)
{ {
g_return_if_fail(sender != NULL); g_return_if_fail(sender != NULL);
@ -476,8 +474,8 @@ matrix_api_filter_rules_add_excluded_sender(MatrixAPIFilterRules *rules,
} }
/** /**
* matrix_api_filter_rules_delete_excluded_sender: * matrix_filter_rules_delete_excluded_sender:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @sender: (in): the Matrix user ID to remove from the excluded * @sender: (in): the Matrix user ID to remove from the excluded
* senders list * senders list
* *
@ -485,8 +483,8 @@ matrix_api_filter_rules_add_excluded_sender(MatrixAPIFilterRules *rules,
* filtered event list. * filtered event list.
*/ */
void void
matrix_api_filter_rules_delete_excluded_sender(MatrixAPIFilterRules *rules, matrix_filter_rules_delete_excluded_sender(MatrixFilterRules *rules,
const gchar *sender) const gchar *sender)
{ {
GList *sender_element; GList *sender_element;
@ -501,8 +499,8 @@ matrix_api_filter_rules_delete_excluded_sender(MatrixAPIFilterRules *rules,
} }
/** /**
* matrix_api_filter_rules_get_excluded_senders: * matrix_filter_rules_get_excluded_senders:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* *
* Get the list of user IDs that will be excluded in the filtered * Get the list of user IDs that will be excluded in the filtered
* events. * events.
@ -512,18 +510,18 @@ matrix_api_filter_rules_delete_excluded_sender(MatrixAPIFilterRules *rules,
* owned by @rules and should not be freed nor modified. * owned by @rules and should not be freed nor modified.
*/ */
const GList * const GList *
matrix_api_filter_rules_get_excluded_senders(MatrixAPIFilterRules *rules) matrix_filter_rules_get_excluded_senders(MatrixFilterRules *rules)
{ {
return rules->excluded_senders; return rules->excluded_senders;
} }
/** /**
* matrix_api_filter_rules_set_rooms: * matrix_filter_rules_set_rooms:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @rooms: (in) (element-type utf8) (transfer full) (allow-none): a * @rooms: (in) (element-type utf8) (transfer full) (allow-none): a
* list of room IDs. Events from these rooms will be included * list of room IDs. Events from these rooms will be included
* in the filtered event list.If %NULL then all rooms are * in the filtered event list.If %NULL then all rooms are
* included. See matrix_api_filter_rules_add_sender() for * included. See matrix_filter_rules_add_sender() for
* wildcarding possibilities * wildcarding possibilities
* *
* Set the list of room IDs to include in the filtered events. @rules * Set the list of room IDs to include in the filtered events. @rules
@ -531,17 +529,17 @@ matrix_api_filter_rules_get_excluded_senders(MatrixAPIFilterRules *rules)
* directly after this call. * directly after this call.
*/ */
void void
matrix_api_filter_rules_set_rooms(MatrixAPIFilterRules *rules, GList *rooms) matrix_filter_rules_set_rooms(MatrixFilterRules *rules, GList *rooms)
{ {
g_list_free_full(rules->rooms, g_free); g_list_free_full(rules->rooms, g_free);
rules->rooms = rooms; rules->rooms = rooms;
} }
/** /**
* matrix_api_filter_rules_add_room: * matrix_filter_rules_add_room:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @room: (in): a room ID to add to the included rooms list. See * @room: (in): a room ID to add to the included rooms list. See
* matrix_api_filter_rules_add_sender() for wildcarding * matrix_filter_rules_add_sender() for wildcarding
* possibilities * possibilities
* *
* Add @room to the list of room IDs to include in the filtered * Add @room to the list of room IDs to include in the filtered
@ -549,8 +547,7 @@ matrix_api_filter_rules_set_rooms(MatrixAPIFilterRules *rules, GList *rooms)
* nothing happens. * nothing happens.
*/ */
void void
matrix_api_filter_rules_add_room(MatrixAPIFilterRules *rules, matrix_filter_rules_add_room(MatrixFilterRules *rules, const gchar *room)
const gchar *room)
{ {
g_return_if_fail(room != NULL); g_return_if_fail(room != NULL);
@ -560,16 +557,15 @@ matrix_api_filter_rules_add_room(MatrixAPIFilterRules *rules,
} }
/** /**
* matrix_api_filter_rules_delete_room: * matrix_filter_rules_delete_room:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @room: (in): the room ID to remove from the rooms list * @room: (in): the room ID to remove from the rooms list
* *
* Remove @room from the list of room IDs to include in the filtered * Remove @room from the list of room IDs to include in the filtered
* event list. * event list.
*/ */
void void
matrix_api_filter_rules_delete_room(MatrixAPIFilterRules *rules, matrix_filter_rules_delete_room(MatrixFilterRules *rules, const gchar *room)
const gchar *room)
{ {
GList *room_element; GList *room_element;
@ -583,8 +579,8 @@ matrix_api_filter_rules_delete_room(MatrixAPIFilterRules *rules,
} }
/** /**
* matrix_api_filter_rules_get_rooms: * matrix_filter_rules_get_rooms:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* *
* Get the list of room IDs that will be included in the filtered * Get the list of room IDs that will be included in the filtered
* events. * events.
@ -594,40 +590,38 @@ matrix_api_filter_rules_delete_room(MatrixAPIFilterRules *rules,
* and should not be freed nor modified * and should not be freed nor modified
*/ */
const GList * const GList *
matrix_api_filter_rules_get_rooms(MatrixAPIFilterRules *rules) matrix_filter_rules_get_rooms(MatrixFilterRules *rules)
{ {
return rules->rooms; return rules->rooms;
} }
/** /**
* matrix_api_filter_rules_set_excluded_rooms: * matrix_filter_rules_set_excluded_rooms:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @rooms: (in) (element-type utf8) (transfer full) (allow-none): a * @rooms: (in) (element-type utf8) (transfer full) (allow-none): a
* list of room IDs. Events from these rooms will be included * list of room IDs. Events from these rooms will be included
* in the filtered event list.If %NULL, then all rooms are * in the filtered event list.If %NULL, then all rooms are
* included. See matrix_api_filter_rules_add_sender() for * included. See matrix_filter_rules_add_sender() for
* wildcarding possibilities * wildcarding possibilities
* *
* Set the list of room IDs to exclude from the filtered events. A * Set the list of room IDs to exclude from the filtered events. A
* matching room will be excluded even if it is listed in the rooms * matching room will be excluded even if it is listed in the rooms
* list (specified by * list (specified by e.g. matrix_filter_rules_set_rooms()). @rules
* e.g. matrix_api_filter_rules_set_rooms()). @rules takes ownership * takes ownership of @rooms, so it should not be freed nor modified
* of @rooms, so it should not be freed nor modified directly after * directly after this call.
* this call.
*/ */
void void
matrix_api_filter_rules_set_excluded_rooms(MatrixAPIFilterRules *rules, matrix_filter_rules_set_excluded_rooms(MatrixFilterRules *rules, GList *rooms)
GList *rooms)
{ {
g_list_free_full(rules->excluded_rooms, g_free); g_list_free_full(rules->excluded_rooms, g_free);
rules->excluded_rooms = rooms; rules->excluded_rooms = rooms;
} }
/** /**
* matrix_api_filter_rules_add_excluded_room: * matrix_filter_rules_add_excluded_room:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @room: (in): a room ID to add to the excluded rooms list. See * @room: (in): a room ID to add to the excluded rooms list. See
* matrix_api_filter_rules_add_sender() for wildcarding * matrix_filter_rules_add_sender() for wildcarding
* possibilities * possibilities
* *
* Add @room to the list of room IDs to exclude from the filtered * Add @room to the list of room IDs to exclude from the filtered
@ -635,8 +629,8 @@ matrix_api_filter_rules_set_excluded_rooms(MatrixAPIFilterRules *rules,
* happens. * happens.
*/ */
void void
matrix_api_filter_rules_add_excluded_room(MatrixAPIFilterRules *rules, matrix_filter_rules_add_excluded_room(MatrixFilterRules *rules,
const gchar *room) const gchar *room)
{ {
g_return_if_fail(room != NULL); g_return_if_fail(room != NULL);
@ -648,16 +642,16 @@ matrix_api_filter_rules_add_excluded_room(MatrixAPIFilterRules *rules,
} }
/** /**
* matrix_api_filter_rules_delete_excluded_room: * matrix_filter_rules_delete_excluded_room:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @room: (in): the room ID to remove from the excluded rooms list * @room: (in): the room ID to remove from the excluded rooms list
* *
* Remove @room from the list of room IDs to exclude from the filtered * Remove @room from the list of room IDs to exclude from the filtered
* event list. * event list.
*/ */
void void
matrix_api_filter_rules_delete_excluded_room(MatrixAPIFilterRules *rules, matrix_filter_rules_delete_excluded_room(MatrixFilterRules *rules,
const gchar *room) const gchar *room)
{ {
GList *room_element; GList *room_element;
@ -672,8 +666,8 @@ matrix_api_filter_rules_delete_excluded_room(MatrixAPIFilterRules *rules,
} }
/** /**
* matrix_api_filter_rules_get_excluded_rooms: * matrix_filter_rules_get_excluded_rooms:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* *
* Get the list of room IDs that will be excluded in the filtered * Get the list of room IDs that will be excluded in the filtered
* events. * events.
@ -683,68 +677,68 @@ matrix_api_filter_rules_delete_excluded_room(MatrixAPIFilterRules *rules,
* owned by @rules and should not be freed nor modified. * owned by @rules and should not be freed nor modified.
*/ */
const GList * const GList *
matrix_api_filter_rules_get_excluded_rooms(MatrixAPIFilterRules *rules) matrix_filter_rules_get_excluded_rooms(MatrixFilterRules *rules)
{ {
return rules->excluded_rooms; return rules->excluded_rooms;
} }
/** /**
* matrix_api_filter_rules_set_types: * matrix_filter_rules_set_types:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @types: (in) (element-type utf8) (transfer full) (allow-none): a * @types: (in) (element-type utf8) (transfer full) (allow-none): a
* list of event types to include. If %NULL then all event * list of event types to include. If %NULL then all event
* types are included. See * types are included. See
* matrix_api_filter_rules_add_sender() for wildcarding * matrix_filter_rules_add_sender() for wildcarding
* possibilities * possibilities
* *
* Set the list of event types to be included in the filtered events. * Set the list of event types to be included in the filtered events.
*/ */
void void
matrix_api_filter_rules_set_types(MatrixAPIFilterRules *rules, GList *types) matrix_filter_rules_set_types(MatrixFilterRules *rules, GList *types)
{ {
g_list_free_full(rules->types, g_free); g_list_free_full(rules->types, g_free);
rules->types = types; rules->types = types;
} }
/** /**
* matrix_api_filter_rules_add_type: * matrix_filter_rules_add_type:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @type: (in): an event type to add to the list of included * @type: (in): an event type to add to the list of included
* events. See matrix_api_filter_rules_add_sender() for * events. See matrix_filter_rules_add_sender() for wildcarding
* wildcarding possibilities * possibilities
* *
* Add @type to the list of event types to include in the filtered * Add @type to the list of event types to include in the filtered
* event list. If @type is already included in the types list, nothing * event list. If @type is already included in the types list, nothing
* happens. * happens.
*/ */
void void
matrix_api_filter_rules_add_type(MatrixAPIFilterRules *rules, const gchar *type) matrix_filter_rules_add_type(MatrixFilterRules *rules, const gchar *event_type)
{ {
g_return_if_fail(type != NULL); g_return_if_fail(event_type != NULL);
if (g_list_find_custom(rules->types, type, (GCompareFunc)g_strcmp0)) { if (g_list_find_custom(rules->types, event_type, (GCompareFunc)g_strcmp0)) {
rules->types = g_list_prepend(rules->types, g_strdup(type)); rules->types = g_list_prepend(rules->types, g_strdup(event_type));
} }
} }
/** /**
* matrix_api_filter_rules_delete_type: * matrix_filter_rules_delete_type:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @type: (in): a type to remove from the list of included event * @type: (in): a type to remove from the list of included event
* types. See matrix_api_filter_rules_add_sender() for * types. See matrix_filter_rules_add_sender() for
* wildcarding possibilities * wildcarding possibilities
* *
* Remove @type from the list of excluded event type list. * Remove @type from the list of excluded event type list.
*/ */
void void
matrix_api_filter_rules_delete_type(MatrixAPIFilterRules *rules, matrix_filter_rules_delete_type(MatrixFilterRules *rules,
const gchar *type) const gchar *event_type)
{ {
GList *type_element; GList *type_element;
g_return_if_fail(type != NULL); g_return_if_fail(event_type != NULL);
while (type_element = g_list_find_custom(rules->types, type, while (type_element = g_list_find_custom(rules->types, event_type,
(GCompareFunc)g_strcmp0)) { (GCompareFunc)g_strcmp0)) {
rules->types = g_list_remove_link(rules->types, type_element); rules->types = g_list_remove_link(rules->types, type_element);
g_list_free_full(type_element, g_free); g_list_free_full(type_element, g_free);
@ -752,8 +746,8 @@ matrix_api_filter_rules_delete_type(MatrixAPIFilterRules *rules,
} }
/** /**
* matrix_api_filter_rules_get_types: * matrix_filter_rules_get_types:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* *
* Get the list of event types that will be included in the filtered * Get the list of event types that will be included in the filtered
* events. * events.
@ -763,59 +757,58 @@ matrix_api_filter_rules_delete_type(MatrixAPIFilterRules *rules,
* @rules and should not be freed nor modified * @rules and should not be freed nor modified
*/ */
const GList * const GList *
matrix_api_filter_rules_get_types(MatrixAPIFilterRules *rules) matrix_filter_rules_get_types(MatrixFilterRules *rules)
{ {
return rules->types; return rules->types;
} }
/** /**
* matrix_api_filter_rules_set_excluded_types: * matrix_filter_rules_set_excluded_types:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @types: (in) (element-type utf8) (transfer full) (allow-none): a * @types: (in) (element-type utf8) (transfer full) (allow-none): a
* list of event types to exclude. If %NULL then no event * list of event types to exclude. If %NULL then no event
* types are excluded. A matching type will be excluded even * types are excluded. A matching type will be excluded even
* if it is listed in the included types. See * if it is listed in the included types. See
* matrix_api_filter_rules_add_sender() for wildcarding * matrix_filter_rules_add_sender() for wildcarding
* possibilities * possibilities
* *
* Set the list of event types to be excluded from the filtered * Set the list of event types to be excluded from the filtered
* events. A matching type will be excluded even if it is listed in * events. A matching type will be excluded even if it is listed in
* the types list (specified by * the types list (specified by
* e.g. matrix_api_filter_rules_set_types()). * e.g. matrix_filter_rules_set_types()).
*/ */
void void
matrix_api_filter_rules_set_excluded_types(MatrixAPIFilterRules *rules, matrix_filter_rules_set_excluded_types(MatrixFilterRules *rules, GList *types)
GList *types)
{ {
g_list_free_full(rules->excluded_types, g_free); g_list_free_full(rules->excluded_types, g_free);
rules->excluded_types = types; rules->excluded_types = types;
} }
/** /**
* matrix_api_filter_rules_add_excluded_type: * matrix_filter_rules_add_excluded_type:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @type: (in): an event type to add to the excluded event type * @type: (in): an event type to add to the excluded event type
* list. See matrix_api_filter_rules_add_sender() for * list. See matrix_filter_rules_add_sender() for wildcarding
* wildcarding possibilities * possibilities
* *
* Add @type to the list of excluded event types. * Add @type to the list of excluded event types.
*/ */
void void
matrix_api_filter_rules_add_excluded_type(MatrixAPIFilterRules *rules, matrix_filter_rules_add_excluded_type(MatrixFilterRules *rules,
const gchar *type) const gchar *event_type)
{ {
g_return_if_fail(type != NULL); g_return_if_fail(event_type != NULL);
if (!g_list_find_custom(rules->excluded_types, type, if (!g_list_find_custom(rules->excluded_types, event_type,
(GCompareFunc)g_strcmp0)) { (GCompareFunc)g_strcmp0)) {
rules->excluded_types = g_list_prepend(rules->excluded_types, rules->excluded_types = g_list_prepend(rules->excluded_types,
g_strdup(type)); g_strdup(event_type));
} }
} }
/** /**
* matrix_api_filter_rules_delete_excluded_type: * matrix_filter_rules_delete_excluded_type:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @type: (in): the event type to be removed from the excluded types * @type: (in): the event type to be removed from the excluded types
* list * list
* *
@ -823,14 +816,14 @@ matrix_api_filter_rules_add_excluded_type(MatrixAPIFilterRules *rules,
* filtered event list. * filtered event list.
*/ */
void void
matrix_api_filter_rules_delete_excluded_type(MatrixAPIFilterRules *rules, matrix_filter_rules_delete_excluded_type(MatrixFilterRules *rules,
const gchar *type) const gchar *event_type)
{ {
GList *type_element; GList *type_element;
g_return_if_fail(type != NULL); g_return_if_fail(event_type != NULL);
while (type_element = g_list_find_custom(rules->excluded_types, type, while (type_element = g_list_find_custom(rules->excluded_types, event_type,
(GCompareFunc)g_strcmp0)) { (GCompareFunc)g_strcmp0)) {
rules->excluded_types = g_list_remove_link(rules->excluded_types, rules->excluded_types = g_list_remove_link(rules->excluded_types,
type_element); type_element);
@ -839,8 +832,8 @@ matrix_api_filter_rules_delete_excluded_type(MatrixAPIFilterRules *rules,
} }
/** /**
* matrix_api_filter_rules_get_excluded_types: * matrix_filter_rules_get_excluded_types:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* *
* Get the list of event types that will be excluded from the filtered * Get the list of event types that will be excluded from the filtered
* events. * events.
@ -850,7 +843,7 @@ matrix_api_filter_rules_delete_excluded_type(MatrixAPIFilterRules *rules,
* @rules and should not be freed nor modified * @rules and should not be freed nor modified
*/ */
const GList * const GList *
matrix_api_filter_rules_get_excluded_types(MatrixAPIFilterRules *rules) matrix_filter_rules_get_excluded_types(MatrixFilterRules *rules)
{ {
return rules->excluded_types; return rules->excluded_types;
} }
@ -862,8 +855,8 @@ json_add_string(gchar *str, JsonBuilder *builder)
} }
/** /**
* matrix_api_filter_rules_get_json_node: * matrix_filter_rules_get_json_node:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* *
* Gets the #JsonNode representation of this filtering ruleset. * Gets the #JsonNode representation of this filtering ruleset.
* *
@ -871,7 +864,7 @@ json_add_string(gchar *str, JsonBuilder *builder)
* data as a #JsonNode * data as a #JsonNode
*/ */
JsonNode * JsonNode *
matrix_api_filter_rules_get_json_node(MatrixAPIFilterRules *rules) matrix_filter_rules_get_json_node(MatrixFilterRules *rules)
{ {
JsonBuilder *builder; JsonBuilder *builder;
JsonNode *node; JsonNode *node;
@ -934,8 +927,8 @@ matrix_api_filter_rules_get_json_node(MatrixAPIFilterRules *rules)
} }
/** /**
* matrix_api_filter_rules_get_json_data: * matrix_filter_rules_get_json_data:
* @rules: a #MatrixAPIFilterRules * @rules: a #MatrixFilterRules
* @datalen: (out): storage for the the length of the JSON data or * @datalen: (out): storage for the the length of the JSON data or
* %NULL * %NULL
* *
@ -946,11 +939,10 @@ matrix_api_filter_rules_get_json_node(MatrixAPIFilterRules *rules)
* rule data as a string * rule data as a string
*/ */
gchar * gchar *
matrix_api_filter_rules_get_json_data(MatrixAPIFilterRules *rules, matrix_filter_rules_get_json_data(MatrixFilterRules *rules, gsize *datalen)
gsize *datalen)
{ {
JsonGenerator *generator; JsonGenerator *generator;
JsonNode *node = matrix_api_filter_rules_get_json_node(rules); JsonNode *node = matrix_filter_rules_get_json_node(rules);
gchar *data; gchar *data;
generator = json_generator_new(); generator = json_generator_new();
@ -970,9 +962,9 @@ matrix_api_filter_rules_get_json_data(MatrixAPIFilterRules *rules,
*/ */
struct _MatrixAPIRoomFilter { struct _MatrixAPIRoomFilter {
gboolean include_leave; gboolean include_leave;
MatrixAPIFilterRules *ephemeral; MatrixFilterRules *ephemeral;
MatrixAPIFilterRules *state; MatrixFilterRules *state;
MatrixAPIFilterRules *timeline; MatrixFilterRules *timeline;
guint refcount; guint refcount;
}; };
@ -1002,15 +994,15 @@ static void
matrix_api_room_filter_free(MatrixAPIRoomFilter *filter) matrix_api_room_filter_free(MatrixAPIRoomFilter *filter)
{ {
if (filter->ephemeral) { if (filter->ephemeral) {
matrix_api_filter_rules_unref(filter->ephemeral); matrix_filter_rules_unref(filter->ephemeral);
} }
if (filter->state) { if (filter->state) {
matrix_api_filter_rules_unref(filter->state); matrix_filter_rules_unref(filter->state);
} }
if (filter->timeline) { if (filter->timeline) {
matrix_api_filter_rules_unref(filter->timeline); matrix_filter_rules_unref(filter->timeline);
} }
g_free(filter); g_free(filter);
@ -1088,13 +1080,13 @@ matrix_api_room_filter_get_include_leave(MatrixAPIRoomFilter *filter)
*/ */
void void
matrix_api_room_filter_set_ephemeral(MatrixAPIRoomFilter *filter, matrix_api_room_filter_set_ephemeral(MatrixAPIRoomFilter *filter,
MatrixAPIFilterRules *rules) MatrixFilterRules *rules)
{ {
if (filter->ephemeral) { if (filter->ephemeral) {
matrix_api_filter_rules_unref(filter->ephemeral); matrix_filter_rules_unref(filter->ephemeral);
} }
filter->ephemeral = matrix_api_filter_rules_ref(rules); filter->ephemeral = matrix_filter_rules_ref(rules);
} }
/** /**
@ -1106,7 +1098,7 @@ matrix_api_room_filter_set_ephemeral(MatrixAPIRoomFilter *filter,
* *
* Returns: (transfer none): the filtering rules for ephemeral events. * Returns: (transfer none): the filtering rules for ephemeral events.
*/ */
MatrixAPIFilterRules * MatrixFilterRules *
matrix_api_room_filter_get_ephemeral(MatrixAPIRoomFilter *filter) matrix_api_room_filter_get_ephemeral(MatrixAPIRoomFilter *filter)
{ {
return filter->ephemeral; return filter->ephemeral;
@ -1122,13 +1114,13 @@ matrix_api_room_filter_get_ephemeral(MatrixAPIRoomFilter *filter)
*/ */
void void
matrix_api_room_filter_set_state(MatrixAPIRoomFilter *filter, matrix_api_room_filter_set_state(MatrixAPIRoomFilter *filter,
MatrixAPIFilterRules *rules) MatrixFilterRules *rules)
{ {
if (filter->state) { if (filter->state) {
matrix_api_filter_rules_unref(filter->state); matrix_filter_rules_unref(filter->state);
} }
filter->state = matrix_api_filter_rules_ref(rules); filter->state = matrix_filter_rules_ref(rules);
} }
/** /**
@ -1139,7 +1131,7 @@ matrix_api_room_filter_set_state(MatrixAPIRoomFilter *filter,
* *
* Returns: (transfer none): the filtering rules for state events * Returns: (transfer none): the filtering rules for state events
*/ */
MatrixAPIFilterRules * MatrixFilterRules *
matrix_api_room_filter_get_state(MatrixAPIRoomFilter *filter) matrix_api_room_filter_get_state(MatrixAPIRoomFilter *filter)
{ {
return filter->state; return filter->state;
@ -1155,13 +1147,13 @@ matrix_api_room_filter_get_state(MatrixAPIRoomFilter *filter)
*/ */
void void
matrix_api_room_filter_set_timeline(MatrixAPIRoomFilter *filter, matrix_api_room_filter_set_timeline(MatrixAPIRoomFilter *filter,
MatrixAPIFilterRules *rules) MatrixFilterRules *rules)
{ {
if (filter->timeline) { if (filter->timeline) {
matrix_api_filter_rules_unref(filter->timeline); matrix_filter_rules_unref(filter->timeline);
} }
filter->timeline = matrix_api_filter_rules_ref(rules); filter->timeline = matrix_filter_rules_ref(rules);
} }
/** /**
@ -1173,7 +1165,7 @@ matrix_api_room_filter_set_timeline(MatrixAPIRoomFilter *filter,
* *
* Returns: (transfer none): the filtering rules for timeline events * Returns: (transfer none): the filtering rules for timeline events
*/ */
MatrixAPIFilterRules * MatrixFilterRules *
matrix_api_room_filter_get_timeline(MatrixAPIRoomFilter *filter) matrix_api_room_filter_get_timeline(MatrixAPIRoomFilter *filter)
{ {
return filter->timeline; return filter->timeline;
@ -1203,21 +1195,21 @@ matrix_api_room_filter_get_json_node(MatrixAPIRoomFilter *filter)
if (filter->ephemeral) { if (filter->ephemeral) {
json_builder_set_member_name(builder, "ephemeral"); json_builder_set_member_name(builder, "ephemeral");
json_builder_add_value(builder, json_builder_add_value(builder,
matrix_api_filter_rules_get_json_node( matrix_filter_rules_get_json_node(
filter->ephemeral)); filter->ephemeral));
} }
if (filter->state) { if (filter->state) {
json_builder_set_member_name(builder, "state"); json_builder_set_member_name(builder, "state");
json_builder_add_value(builder, json_builder_add_value(builder,
matrix_api_filter_rules_get_json_node( matrix_filter_rules_get_json_node(
filter->state)); filter->state));
} }
if (filter->timeline) { if (filter->timeline) {
json_builder_set_member_name(builder, "timeline"); json_builder_set_member_name(builder, "timeline");
json_builder_add_value(builder, json_builder_add_value(builder,
matrix_api_filter_rules_get_json_node( matrix_filter_rules_get_json_node(
filter->timeline)); filter->timeline));
} }
@ -1267,7 +1259,7 @@ matrix_api_room_filter_get_json_data(MatrixAPIRoomFilter *filter,
struct _MatrixAPIFilter { struct _MatrixAPIFilter {
GList *event_fields; GList *event_fields;
MatrixEventFormat event_format; MatrixEventFormat event_format;
MatrixAPIFilterRules *presence; MatrixFilterRules *presence;
MatrixAPIRoomFilter *room; MatrixAPIRoomFilter *room;
guint refcount; guint refcount;
}; };
@ -1300,7 +1292,7 @@ matrix_api_filter_free(MatrixAPIFilter *filter)
g_list_free_full(filter->event_fields, g_free); g_list_free_full(filter->event_fields, g_free);
if (filter->presence) { if (filter->presence) {
matrix_api_filter_rules_unref(filter->presence); matrix_filter_rules_unref(filter->presence);
} }
if (filter->room) { if (filter->room) {
@ -1466,13 +1458,13 @@ matrix_api_filter_get_event_format(MatrixAPIFilter *filter)
*/ */
void void
matrix_api_filter_set_presence_filter(MatrixAPIFilter *filter, matrix_api_filter_set_presence_filter(MatrixAPIFilter *filter,
MatrixAPIFilterRules *presence_filter) MatrixFilterRules *presence_filter)
{ {
if (filter->presence) { if (filter->presence) {
matrix_api_filter_rules_unref(filter->presence); matrix_filter_rules_unref(filter->presence);
} }
filter->presence = matrix_api_filter_rules_ref(presence_filter); filter->presence = matrix_filter_rules_ref(presence_filter);
} }
/** /**
@ -1485,7 +1477,7 @@ matrix_api_filter_set_presence_filter(MatrixAPIFilter *filter,
* is owned by @filter; if the callee wants to use it * is owned by @filter; if the callee wants to use it
* separately, it should create a reference for it * separately, it should create a reference for it
*/ */
MatrixAPIFilterRules * MatrixFilterRules *
matrix_api_filter_get_presence_filter(MatrixAPIFilter *filter) matrix_api_filter_get_presence_filter(MatrixAPIFilter *filter)
{ {
return filter->presence; return filter->presence;
@ -1554,7 +1546,7 @@ matrix_api_filter_get_json_node(MatrixAPIFilter *filter)
TRUE)); TRUE));
json_builder_set_member_name(builder, "presence"); json_builder_set_member_name(builder, "presence");
tmp = matrix_api_filter_rules_get_json_node(filter->presence); tmp = matrix_filter_rules_get_json_node(filter->presence);
json_builder_add_value(builder, tmp); json_builder_add_value(builder, tmp);
json_node_free(tmp); json_node_free(tmp);

118
src/matrix-types.h
View File

@ -114,62 +114,56 @@ typedef enum {
MATRIX_ACCOUNT_KIND_GUEST MATRIX_ACCOUNT_KIND_GUEST
} MatrixAccountKind; } MatrixAccountKind;
typedef struct _MatrixAPIFilterRules MatrixAPIFilterRules; typedef struct _MatrixFilterRules MatrixFilterRules;
GType matrix_api_filter_rules_get_type(void); GType matrix_filter_rules_get_type(void);
#define MATRIX_TYPE_API_FILTER_RULES (matrix_api_filter_rules_get_type()) #define MATRIX_TYPE_FILTER_RULES (matrix_filter_rules_get_type())
MatrixAPIFilterRules *matrix_api_filter_rules_new(void); MatrixFilterRules *matrix_filter_rules_new(void);
MatrixAPIFilterRules *matrix_api_filter_rules_ref(MatrixAPIFilterRules *rules); MatrixFilterRules *matrix_filter_rules_ref(MatrixFilterRules *rules);
void matrix_api_filter_rules_unref(MatrixAPIFilterRules *rules); void matrix_filter_rules_unref(MatrixFilterRules *rules);
void matrix_api_filter_rules_set_limit(MatrixAPIFilterRules *rules, void matrix_filter_rules_set_limit(MatrixFilterRules *rules, guint limit);
guint limit); guint matrix_filter_rules_get_limit(MatrixFilterRules *rules);
guint matrix_api_filter_rules_get_limit(MatrixAPIFilterRules *rules); void matrix_filter_rules_set_rooms(MatrixFilterRules *rules, GList *rooms);
void matrix_api_filter_rules_set_rooms(MatrixAPIFilterRules *rules, void matrix_filter_rules_add_room(MatrixFilterRules *rules, const gchar *room);
GList *rooms); void matrix_filter_rules_delete_room(MatrixFilterRules *rules,
void matrix_api_filter_rules_add_room(MatrixAPIFilterRules *rules, const gchar *room);
const gchar *room); const GList *matrix_filter_rules_get_rooms(MatrixFilterRules *rules);
void matrix_api_filter_rules_delete_room(MatrixAPIFilterRules *rules, void matrix_filter_rules_set_excluded_rooms(MatrixFilterRules *rules,
const gchar *room); GList *rooms);
const GList *matrix_api_filter_rules_get_rooms(MatrixAPIFilterRules *rules); void matrix_filter_rules_add_excluded_room(MatrixFilterRules *rules,
void matrix_api_filter_rules_set_excluded_rooms(MatrixAPIFilterRules *rules, const gchar *room);
GList *rooms); void matrix_filter_rules_delete_excluded_room(MatrixFilterRules *rules,
void matrix_api_filter_rules_add_excluded_room(MatrixAPIFilterRules *rules, const gchar *room);
const gchar *room); const GList *matrix_filter_rules_get_excluded_rooms(MatrixFilterRules *rules);
void matrix_api_filter_rules_delete_excluded_room(MatrixAPIFilterRules *rules, void matrix_filter_rules_set_senders(MatrixFilterRules *rules, GList *senders);
const gchar *room); void matrix_filter_rules_add_sender(MatrixFilterRules *rules,
const GList *matrix_api_filter_rules_get_excluded_rooms(MatrixAPIFilterRules *rules); const gchar *sender);
void matrix_api_filter_rules_set_senders(MatrixAPIFilterRules *rules, void matrix_filter_rules_delete_sender(MatrixFilterRules *rules,
GList *senders); const gchar *sender);
void matrix_api_filter_rules_add_sender(MatrixAPIFilterRules *rules, const GList *matrix_filter_rules_get_senders(MatrixFilterRules *rules);
const gchar *sender); void matrix_filter_rules_set_excluded_senders(MatrixFilterRules *rules,
void matrix_api_filter_rules_delete_sender(MatrixAPIFilterRules *rules, GList *senders);
const gchar *sender); void matrix_filter_rules_add_excluded_sender(MatrixFilterRules *rules,
const GList *matrix_api_filter_rules_get_senders(MatrixAPIFilterRules *rules); const gchar *sender);
void matrix_api_filter_rules_set_excluded_senders(MatrixAPIFilterRules *rules, void matrix_filter_rules_delete_excluded_sender(MatrixFilterRules *rules,
GList *senders); const gchar *sender);
void matrix_api_filter_rules_add_excluded_sender(MatrixAPIFilterRules *rules, const GList *matrix_filter_rules_get_excluded_senders(MatrixFilterRules *rules);
const gchar *sender); void matrix_filter_rules_set_types(MatrixFilterRules *rules, GList *types);
void matrix_api_filter_rules_delete_excluded_sender(MatrixAPIFilterRules *rules, void matrix_filter_rules_add_type(MatrixFilterRules *rules, const gchar *type);
const gchar *sender); void matrix_filter_rules_delete_type(MatrixFilterRules *rules,
const GList *matrix_api_filter_rules_get_excluded_senders(MatrixAPIFilterRules *rules); const gchar *type);
void matrix_api_filter_rules_set_types(MatrixAPIFilterRules *rules, const GList *matrix_filter_rules_get_types(MatrixFilterRules *rules);
GList *types); void matrix_filter_rules_set_excluded_types(MatrixFilterRules *rules,
void matrix_api_filter_rules_add_type(MatrixAPIFilterRules *rules, GList *types);
const gchar *type); void matrix_filter_rules_add_excluded_type(MatrixFilterRules *rules,
void matrix_api_filter_rules_delete_type(MatrixAPIFilterRules *rules, const gchar *type);
const gchar *type); void matrix_filter_rules_delete_excluded_type(MatrixFilterRules *rules,
const GList *matrix_api_filter_rules_get_types(MatrixAPIFilterRules *rules); const gchar *type);
void matrix_api_filter_rules_set_excluded_types(MatrixAPIFilterRules *rules, const GList *matrix_filter_rules_get_excluded_types(MatrixFilterRules *rules);
GList *types); JsonNode *matrix_filter_rules_get_json_node(MatrixFilterRules *rules);
void matrix_api_filter_rules_add_excluded_type(MatrixAPIFilterRules *rules, gchar *matrix_filter_rules_get_json_data(MatrixFilterRules *rules,
const gchar *type); gsize *datalen);
void matrix_api_filter_rules_delete_excluded_type(MatrixAPIFilterRules *rules,
const gchar *type);
const GList *matrix_api_filter_rules_get_excluded_types(MatrixAPIFilterRules *rules);
JsonNode *matrix_api_filter_rules_get_json_node(MatrixAPIFilterRules *rules);
gchar *matrix_api_filter_rules_get_json_data(MatrixAPIFilterRules *rules,
gsize *datalen);
typedef struct _MatrixAPIRoomFilter MatrixAPIRoomFilter; typedef struct _MatrixAPIRoomFilter MatrixAPIRoomFilter;
@ -183,14 +177,14 @@ void matrix_api_room_filter_set_include_leave(MatrixAPIRoomFilter *filter,
gboolean include_leave); gboolean include_leave);
gboolean matrix_api_room_filter_get_include_leave(MatrixAPIRoomFilter *filter); gboolean matrix_api_room_filter_get_include_leave(MatrixAPIRoomFilter *filter);
void matrix_api_room_filter_set_ephemeral(MatrixAPIRoomFilter *filter, void matrix_api_room_filter_set_ephemeral(MatrixAPIRoomFilter *filter,
MatrixAPIFilterRules *rules); MatrixFilterRules *rules);
MatrixAPIFilterRules *matrix_api_room_filter_get_ephemeral(MatrixAPIRoomFilter *filter); MatrixFilterRules *matrix_api_room_filter_get_ephemeral(MatrixAPIRoomFilter *filter);
void matrix_api_room_filter_set_state(MatrixAPIRoomFilter *filter, void matrix_api_room_filter_set_state(MatrixAPIRoomFilter *filter,
MatrixAPIFilterRules *rules); MatrixFilterRules *rules);
MatrixAPIFilterRules *matrix_api_room_filter_get_state(MatrixAPIRoomFilter *filter); MatrixFilterRules *matrix_api_room_filter_get_state(MatrixAPIRoomFilter *filter);
void matrix_api_room_filter_set_timeline(MatrixAPIRoomFilter *filter, void matrix_api_room_filter_set_timeline(MatrixAPIRoomFilter *filter,
MatrixAPIFilterRules *rules); MatrixFilterRules *rules);
MatrixAPIFilterRules *matrix_api_room_filter_get_timeline(MatrixAPIRoomFilter *filter); MatrixFilterRules *matrix_api_room_filter_get_timeline(MatrixAPIRoomFilter *filter);
JsonNode *matrix_api_room_filter_get_json_node(MatrixAPIRoomFilter *filter); JsonNode *matrix_api_room_filter_get_json_node(MatrixAPIRoomFilter *filter);
gchar *matrix_api_room_filter_get_json_data(MatrixAPIRoomFilter *filter, gchar *matrix_api_room_filter_get_json_data(MatrixAPIRoomFilter *filter,
gsize *datalen); gsize *datalen);
@ -214,8 +208,8 @@ void matrix_api_filter_set_event_format(MatrixAPIFilter *filter,
MatrixEventFormat event_format); MatrixEventFormat event_format);
MatrixEventFormat matrix_api_filter_get_event_format(MatrixAPIFilter *filter); MatrixEventFormat matrix_api_filter_get_event_format(MatrixAPIFilter *filter);
void matrix_api_filter_set_presence_filter(MatrixAPIFilter *filter, void matrix_api_filter_set_presence_filter(MatrixAPIFilter *filter,
MatrixAPIFilterRules *presence_filter); MatrixFilterRules *presence_filter);
MatrixAPIFilterRules *matrix_api_filter_get_presence_filter(MatrixAPIFilter *filter); MatrixFilterRules *matrix_api_filter_get_presence_filter(MatrixAPIFilter *filter);
void matrix_api_filter_set_room_filter(MatrixAPIFilter *filter, void matrix_api_filter_set_room_filter(MatrixAPIFilter *filter,
MatrixAPIRoomFilter *room_filter); MatrixAPIRoomFilter *room_filter);
MatrixAPIRoomFilter *matrix_api_filter_get_room_filter(MatrixAPIFilter *filter); MatrixAPIRoomFilter *matrix_api_filter_get_room_filter(MatrixAPIFilter *filter);