Port MatrixEventBase to C
This commit is contained in:
parent
89376c0890
commit
552a36d65d
1
.gitignore
vendored
1
.gitignore
vendored
@ -51,7 +51,6 @@ Makefile.in
|
||||
/src/matrix-client.c
|
||||
/src/matrix-http-api.c
|
||||
/src/matrix-http-client.c
|
||||
/src/matrix-event-base.c
|
||||
/src/matrix-event-presence.c
|
||||
/src/matrix-event-room-base.c
|
||||
/src/matrix-event-room-member.c
|
||||
|
||||
@ -21,7 +21,6 @@ libmatrix_glib_0_0_la_VALA_SOURCES = \
|
||||
matrix-client.vala \
|
||||
matrix-http-api.vala \
|
||||
matrix-http-client.vala \
|
||||
matrix-event-base.vala \
|
||||
matrix-event-room-base.vala \
|
||||
matrix-event-state-base.vala \
|
||||
matrix-event-presence.vala \
|
||||
@ -113,6 +112,7 @@ bin_PROGRAMS = test-api-client test-client
|
||||
INST_H_SRC_FILES = \
|
||||
matrix-types.h \
|
||||
matrix-compacts.h \
|
||||
matrix-event-base.h \
|
||||
utils.h \
|
||||
matrix-profile.h \
|
||||
$(NULL)
|
||||
@ -135,6 +135,7 @@ libmatrix_glib_0_0_la_SOURCES = \
|
||||
matrix-version.c \
|
||||
matrix-types.c \
|
||||
matrix-compacts.c \
|
||||
matrix-event-base.c \
|
||||
matrix-profile.c \
|
||||
utils.c \
|
||||
matrix-enumtypes.c \
|
||||
|
||||
596
src/matrix-event-base.c
Normal file
596
src/matrix-event-base.c
Normal file
@ -0,0 +1,596 @@
|
||||
/*
|
||||
* This file is part of matrix-glib-sdk
|
||||
*
|
||||
* matrix-glib-sdk is free software: you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation, either
|
||||
* version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* matrix-glib-sdk 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 Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with matrix-glib-sdk. If not, see
|
||||
* <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#include "matrix-event-base.h"
|
||||
#include "matrix-enumtypes.h"
|
||||
#include "config.h"
|
||||
|
||||
/**
|
||||
* SECTION:matrix-event-base
|
||||
* @short_description: abstract base class for Matrix events
|
||||
* @title: Base class for events
|
||||
*
|
||||
* #MatrixEventBase is the abstract base class of Matrix events. All event classes in this
|
||||
* library are derived from it, and custom classes should derived from it, too, if one wants to
|
||||
* benefit from #MatrixClient’s (de)serialization capabilities.
|
||||
*
|
||||
* This class only defines the MatrixEventBase:event-type property, which is tied to the
|
||||
* `event_type` field in a JSON representation. Subclasses should not get or set this property.
|
||||
*
|
||||
* Event objects can be created from JSON data (a #JsonNode) by calling
|
||||
* matrix_event_base_new_from_json(), which will return the correct GObject type as long as
|
||||
* it was registered with matrix_event_register_type().
|
||||
*/
|
||||
enum {
|
||||
PROP_0,
|
||||
PROP_EVENT_TYPE,
|
||||
PROP_JSON,
|
||||
NUM_PROPS
|
||||
};
|
||||
|
||||
static GParamSpec* matrix_event_base_properties[NUM_PROPS];
|
||||
static GHashTable *matrix_event_type_handlers = NULL;
|
||||
|
||||
typedef struct {
|
||||
GError* _construct_error;
|
||||
gboolean _inited;
|
||||
JsonNode* _json;
|
||||
gchar *_event_type;
|
||||
} MatrixEventBasePrivate;
|
||||
|
||||
static void matrix_event_base_g_initable_interface_init (GInitableIface *iface);
|
||||
|
||||
/**
|
||||
* MatrixEventBase:
|
||||
*
|
||||
* Abstract base class for event handlers.
|
||||
*/
|
||||
|
||||
/**
|
||||
* MatrixEventBaseClass:
|
||||
* @from_json: function to initialize themselves from JSON data
|
||||
* @to_json: function to export their data to JSON
|
||||
*
|
||||
* Class structure for #MatrixEventBase.
|
||||
*/
|
||||
G_DEFINE_TYPE_EXTENDED(MatrixEventBase, matrix_event_base, G_TYPE_OBJECT, G_TYPE_FLAG_ABSTRACT, G_ADD_PRIVATE (MatrixEventBase) G_IMPLEMENT_INTERFACE(G_TYPE_INITABLE, matrix_event_base_g_initable_interface_init));
|
||||
|
||||
static gboolean
|
||||
matrix_event_base_initable_init(GInitable *g_initable, GCancellable *cancellable, GError **error)
|
||||
{
|
||||
MatrixEventBasePrivate *priv;
|
||||
|
||||
if (cancellable != NULL) {
|
||||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_UNSUPPORTED,
|
||||
"Cancellable initialization not supported");
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
priv = matrix_event_base_get_instance_private(MATRIX_EVENT_BASE(g_initable));
|
||||
|
||||
if (priv->_construct_error != NULL) {
|
||||
g_propagate_error(error, priv->_construct_error);
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
priv->_inited = TRUE;
|
||||
|
||||
return TRUE;
|
||||
}
|
||||
|
||||
static void
|
||||
matrix_event_base_initialize_from_json(MatrixEventBase *matrix_event_base, JsonNode *json_data, GError **error)
|
||||
{
|
||||
MatrixEventBasePrivate *priv = matrix_event_base_get_instance_private(matrix_event_base);
|
||||
JsonObject *root;
|
||||
JsonNode *node;
|
||||
const gchar *json_event_type;
|
||||
GError *inner_error = NULL;
|
||||
|
||||
g_return_if_fail(matrix_event_base != NULL);
|
||||
|
||||
if (json_node_get_node_type(json_data) != JSON_NODE_OBJECT) {
|
||||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INVALID_FORMAT,
|
||||
"The event is not valid");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
root = json_node_get_object(json_data);
|
||||
|
||||
if ((node = json_object_get_member(root, "type")) == NULL) {
|
||||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
|
||||
"Event type is not specified");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
json_event_type = json_node_get_string(node);
|
||||
|
||||
if ((priv->_event_type != NULL) && (g_strcmp0(priv->_event_type, json_event_type) != 0)) {
|
||||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INVALID_TYPE,
|
||||
"Changing event type is not supported");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if ((node = json_object_get_member(root, "content")) == NULL) {
|
||||
g_warning("content key is missing from an %s event", json_event_type);
|
||||
|
||||
// As event type objects depend on having this node, let’s add it now.
|
||||
JsonNode *content_node = json_node_new(JSON_NODE_OBJECT);
|
||||
json_node_set_object(content_node, json_object_new());
|
||||
json_object_set_member(root, "content", content_node);
|
||||
}
|
||||
|
||||
matrix_event_base_from_json(matrix_event_base, json_data, &inner_error);
|
||||
|
||||
if (inner_error != NULL) {
|
||||
g_propagate_error(error, inner_error);
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
g_free(priv->_event_type);
|
||||
priv->_event_type = g_strdup(json_event_type);
|
||||
}
|
||||
|
||||
static void
|
||||
matrix_event_base_real_from_json(MatrixEventBase *matrix_event_base, JsonNode *json_data, GError **error)
|
||||
{
|
||||
MatrixEventBasePrivate *priv = matrix_event_base_get_instance_private(matrix_event_base);
|
||||
JsonObject *root;
|
||||
JsonNode *node;
|
||||
|
||||
g_return_if_fail(matrix_event_base != NULL);
|
||||
|
||||
root = json_node_get_object(json_data);
|
||||
|
||||
if ((node = json_object_get_member(root, "type")) != NULL) {
|
||||
g_free(priv->_event_type);
|
||||
priv->_event_type = g_strdup(json_node_get_string(node));
|
||||
} else if (DEBUG) {
|
||||
g_warning("type is not present in an event");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* matrix_event_base_from_json:
|
||||
* @event: a #MatrixEventBase (or derived) object
|
||||
* @json_data: a #JsonNode to load data from. It must hold a #JsonObject
|
||||
* @error: a #GError, or %NULL to ignore errors
|
||||
*
|
||||
* Load data from a JSON object to the fields of @event.
|
||||
*/
|
||||
void
|
||||
matrix_event_base_from_json(MatrixEventBase *matrix_event_base, JsonNode *json_data, GError **error)
|
||||
{
|
||||
g_return_if_fail(matrix_event_base != NULL);
|
||||
g_return_if_fail(json_data != NULL);
|
||||
g_return_if_fail(json_node_get_node_type(json_data) != JSON_NODE_OBJECT);
|
||||
|
||||
MATRIX_EVENT_BASE_GET_CLASS(matrix_event_base)->from_json(matrix_event_base, json_data, error);
|
||||
}
|
||||
|
||||
static void
|
||||
matrix_event_base_real_to_json(MatrixEventBase *matrix_event_base, JsonNode *json_data, GError **error)
|
||||
{
|
||||
MatrixEventBasePrivate *priv = matrix_event_base_get_instance_private(matrix_event_base);
|
||||
JsonObject *root;
|
||||
|
||||
g_return_if_fail(matrix_event_base != NULL);
|
||||
|
||||
root = json_node_get_object(json_data);
|
||||
|
||||
if (priv->_event_type == NULL) {
|
||||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
|
||||
"Won't generate an event without type");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
json_object_set_string_member(root, "type", priv->_event_type);
|
||||
}
|
||||
|
||||
/**
|
||||
* matrix_event_base_to_json:
|
||||
* @event: a #MatrixEventBase (or derived) object
|
||||
* @json_data: a #JsonNode initialised to hold a #JsonObject
|
||||
* @error: a #GError, or %NULL to ignore errors
|
||||
*
|
||||
* Export event data to a JSON object.
|
||||
*/
|
||||
void
|
||||
matrix_event_base_to_json(MatrixEventBase *matrix_event_base, JsonNode *json_data, GError **error)
|
||||
{
|
||||
g_return_if_fail(matrix_event_base != NULL);
|
||||
g_return_if_fail(json_data != NULL);
|
||||
g_return_if_fail(json_node_get_node_type(json_data) != JSON_NODE_OBJECT);
|
||||
|
||||
MATRIX_EVENT_BASE_GET_CLASS(matrix_event_base)->to_json(matrix_event_base, json_data, error);
|
||||
}
|
||||
|
||||
/**
|
||||
* matrix_event_base_new_from_json:
|
||||
* @event_type: (nullable) (transfer none): an event type
|
||||
* @json_data: (not nullable) (transfer none): a #JsonNode, holding a #JsonObject
|
||||
* @error: (nullable): a #GError, or %NULL to ignore errors
|
||||
*
|
||||
* Create a new #MatrixEventBase derived object based on @event_type. If @event_type is %NULL,
|
||||
* the event type is taken directly from the JSON data, namely the `"event_type"` field.
|
||||
*
|
||||
* After figuring out the event type (either from @event_type or from the event itself), this
|
||||
* function calls matrix_event_get_handler() to get the handler #GType for this event. If
|
||||
* none found, @error is set to #MATRIX_ERROR_INVALID_TYPE, and this function returns %NULL.
|
||||
*
|
||||
* The actual return type of this function is the same as the handling class (which is
|
||||
* required to be a subclass of #MatrixEventBase).
|
||||
*
|
||||
* When object initialisation is done, matrix_event_base_from_json() is called to populate
|
||||
* the event object.
|
||||
*
|
||||
* Returns: (transfer full): a new #MatrixEventBase devired object
|
||||
*/
|
||||
MatrixEventBase *
|
||||
matrix_event_base_new_from_json(const gchar *event_type, JsonNode *json_data, GError **error)
|
||||
{
|
||||
GType event_gtype;
|
||||
MatrixEventBase *ret = NULL;
|
||||
GError *inner_error = NULL;
|
||||
|
||||
if (event_type == NULL) {
|
||||
JsonNode *node;
|
||||
|
||||
if (json_data == NULL) {
|
||||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
|
||||
"Either event_type or json_data must be set!");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if (json_node_get_node_type(json_data) != JSON_NODE_OBJECT) {
|
||||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INVALID_FORMAT,
|
||||
"Event is not a JSON object!");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
if ((node = json_object_get_member(json_node_get_object(json_data), "type")) == NULL) {
|
||||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INCOMPLETE,
|
||||
"event_type is null and JSON object doesn't contain type!");
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
event_type = (gchar *)json_node_get_string(node);
|
||||
}
|
||||
|
||||
if ((event_gtype = matrix_event_get_handler(event_type)) == G_TYPE_NONE) {
|
||||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INVALID_TYPE,
|
||||
"No registered type for event type %s",
|
||||
event_type);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
ret = (MatrixEventBase *)g_object_new(event_gtype,
|
||||
"event_type", event_type,
|
||||
"json", json_data);
|
||||
|
||||
matrix_event_base_initable_init(G_INITABLE(ret), NULL, &inner_error);
|
||||
|
||||
if (inner_error != NULL) {
|
||||
g_propagate_error(error, inner_error);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
MatrixEventBase *
|
||||
matrix_event_base_construct(GType object_type)
|
||||
{
|
||||
return (MatrixEventBase *)g_object_new(object_type, NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
* matrix_event_base_get_event_type:
|
||||
* @event: a #MatrixEventBase (or derived) object
|
||||
*
|
||||
* Get the event type of @event.
|
||||
*
|
||||
* The returned value is owned by @event and should not be freed.
|
||||
*
|
||||
* Returns: (transfer none): the event type
|
||||
*/
|
||||
const gchar *
|
||||
matrix_event_base_get_event_type(MatrixEventBase *matrix_event_base)
|
||||
{
|
||||
MatrixEventBasePrivate *priv = matrix_event_base_get_instance_private(matrix_event_base);
|
||||
|
||||
g_return_val_if_fail(matrix_event_base != NULL, NULL);
|
||||
|
||||
return priv->_event_type;
|
||||
}
|
||||
|
||||
static void
|
||||
matrix_event_base_set_event_type(MatrixEventBase *matrix_event_base, const gchar *event_type)
|
||||
{
|
||||
MatrixEventBasePrivate *priv = matrix_event_base_get_instance_private(matrix_event_base);
|
||||
|
||||
g_return_if_fail(matrix_event_base != NULL);
|
||||
|
||||
g_free(priv->_event_type);
|
||||
priv->_event_type = g_strdup (event_type);
|
||||
|
||||
g_object_notify_by_pspec((GObject *)matrix_event_base,
|
||||
matrix_event_base_properties[PROP_EVENT_TYPE]);
|
||||
}
|
||||
|
||||
JsonNode *
|
||||
matrix_event_base_get_json(MatrixEventBase *matrix_event_base)
|
||||
{
|
||||
MatrixEventBasePrivate *priv;
|
||||
JsonNode *result;
|
||||
JsonNode *content_node;
|
||||
JsonObject *root;
|
||||
JsonObject *content_root;
|
||||
GError *inner_error = NULL;
|
||||
|
||||
g_return_val_if_fail(matrix_event_base != NULL, NULL);
|
||||
|
||||
priv = matrix_event_base_get_instance_private(matrix_event_base);
|
||||
|
||||
result = json_node_new (JSON_NODE_OBJECT);
|
||||
root = json_object_new();
|
||||
json_node_set_object(priv->_json, root);
|
||||
|
||||
content_node = json_node_new(JSON_NODE_OBJECT);
|
||||
content_root = json_object_new();
|
||||
json_node_set_object(content_node, content_root);
|
||||
json_object_set_member(root, "content", content_node);
|
||||
|
||||
matrix_event_base_to_json(matrix_event_base, priv->_json, &inner_error);
|
||||
|
||||
if (inner_error != NULL) {
|
||||
g_error("Unable to generate JSON content: %s", inner_error->message);
|
||||
g_error_free(inner_error);
|
||||
g_object_unref(result);
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
json_node_unref(priv->_json);
|
||||
|
||||
priv->_json = result;
|
||||
|
||||
return priv->_json;
|
||||
}
|
||||
|
||||
static void
|
||||
matrix_event_base_set_json(MatrixEventBase *matrix_event_base, JsonNode *json)
|
||||
{
|
||||
GError* inner_error = NULL;
|
||||
|
||||
g_return_if_fail(matrix_event_base != NULL);
|
||||
|
||||
if (json != NULL) {
|
||||
matrix_event_base_initialize_from_json(matrix_event_base, json, &inner_error);
|
||||
|
||||
if (inner_error != NULL) {
|
||||
g_error("Unable to initialise from JSON data: %s", inner_error->message);
|
||||
g_error_free(inner_error);
|
||||
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
g_object_notify_by_pspec((GObject *)matrix_event_base, matrix_event_base_properties[PROP_JSON]);
|
||||
}
|
||||
|
||||
static void
|
||||
matrix_event_base_get_property(GObject *gobject, guint prop_id, GValue *value, GParamSpec *pspec)
|
||||
{
|
||||
MatrixEventBase *matrix_event_base = MATRIX_EVENT_BASE(gobject);
|
||||
|
||||
switch (prop_id) {
|
||||
case PROP_EVENT_TYPE:
|
||||
g_value_set_string(value, matrix_event_base_get_event_type(matrix_event_base));
|
||||
|
||||
break;
|
||||
case PROP_JSON:
|
||||
g_value_set_boxed(value, matrix_event_base_get_json(matrix_event_base));
|
||||
|
||||
break;
|
||||
default:
|
||||
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, pspec);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
matrix_event_base_set_property(GObject *gobject, guint prop_id, const GValue *value, GParamSpec *pspec)
|
||||
{
|
||||
MatrixEventBase *matrix_event_base = MATRIX_EVENT_BASE(gobject);
|
||||
|
||||
switch (prop_id) {
|
||||
case PROP_EVENT_TYPE:
|
||||
matrix_event_base_set_event_type(matrix_event_base, g_value_get_string(value));
|
||||
|
||||
break;
|
||||
case PROP_JSON:
|
||||
matrix_event_base_set_json(matrix_event_base, g_value_get_boxed(value));
|
||||
|
||||
break;
|
||||
default:
|
||||
G_OBJECT_WARN_INVALID_PROPERTY_ID(gobject, prop_id, pspec);
|
||||
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
static void
|
||||
matrix_event_base_finalize(GObject *gobject)
|
||||
{
|
||||
MatrixEventBase *matrix_event_base = MATRIX_EVENT_BASE(gobject);
|
||||
MatrixEventBasePrivate *priv = matrix_event_base_get_instance_private(matrix_event_base);
|
||||
|
||||
if (priv->_construct_error) {
|
||||
g_error_free(priv->_construct_error);
|
||||
}
|
||||
|
||||
priv->_json = (json_node_unref(priv->_json), NULL);
|
||||
|
||||
g_free(priv->_event_type);
|
||||
|
||||
G_OBJECT_CLASS(matrix_event_base_parent_class)->finalize(gobject);
|
||||
}
|
||||
|
||||
static void
|
||||
matrix_event_base_class_init(MatrixEventBaseClass *klass)
|
||||
{
|
||||
((MatrixEventBaseClass *)klass)->from_json = matrix_event_base_real_from_json;
|
||||
((MatrixEventBaseClass *)klass)->to_json = matrix_event_base_real_to_json;
|
||||
|
||||
G_OBJECT_CLASS(klass)->get_property = matrix_event_base_get_property;
|
||||
G_OBJECT_CLASS(klass)->set_property = matrix_event_base_set_property;
|
||||
G_OBJECT_CLASS(klass)->finalize = matrix_event_base_finalize;
|
||||
|
||||
/**
|
||||
* MatrixEventBase:event-type:
|
||||
*
|
||||
* The type of the event. It should be namespaced similar to the Java package naming
|
||||
* conventions, e.g. `com.example.subdomain.event.type`. It cannot be changed after object
|
||||
* initialization.
|
||||
*/
|
||||
matrix_event_base_properties[PROP_EVENT_TYPE] = g_param_spec_string(
|
||||
"event-type", "event-type", "event-type",
|
||||
NULL,
|
||||
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
|
||||
g_object_class_install_property(G_OBJECT_CLASS(klass),
|
||||
PROP_EVENT_TYPE,
|
||||
matrix_event_base_properties[PROP_EVENT_TYPE]);
|
||||
|
||||
/**
|
||||
* MatrixEventBase:json:
|
||||
*
|
||||
* The event as a JSON node.
|
||||
*/
|
||||
matrix_event_base_properties[PROP_JSON] = g_param_spec_boxed(
|
||||
"json", "json", "json",
|
||||
JSON_TYPE_NODE,
|
||||
G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY);
|
||||
g_object_class_install_property(G_OBJECT_CLASS(klass),
|
||||
PROP_JSON,
|
||||
matrix_event_base_properties[PROP_JSON]);
|
||||
}
|
||||
|
||||
static void
|
||||
matrix_event_base_g_initable_interface_init(GInitableIface *iface)
|
||||
{
|
||||
iface->init = matrix_event_base_initable_init;
|
||||
}
|
||||
|
||||
static void
|
||||
matrix_event_base_init(MatrixEventBase *matrix_event_base)
|
||||
{
|
||||
MatrixEventBasePrivate *priv = matrix_event_base_get_instance_private(matrix_event_base);
|
||||
|
||||
priv->_construct_error = NULL;
|
||||
priv->_inited = FALSE;
|
||||
priv->_event_type = NULL;
|
||||
|
||||
matrix_event_base_set_event_type(matrix_event_base, NULL);
|
||||
}
|
||||
|
||||
/**
|
||||
* matrix_event_get_handler:
|
||||
* @event_type: (transfer none) (not nullable): the event type to look up
|
||||
*
|
||||
* Get the #GType of the class that is registered to handle events with type @event_type.
|
||||
*
|
||||
* Returns: a #GType, or #G_TYPE_NONE if no handler is registered
|
||||
*/
|
||||
GType
|
||||
matrix_event_get_handler(const gchar *event_type)
|
||||
{
|
||||
GTypeClass *klass;
|
||||
|
||||
g_return_val_if_fail(event_type != NULL, G_TYPE_NONE);
|
||||
|
||||
if ((klass = (GTypeClass *)g_hash_table_lookup(matrix_event_type_handlers, event_type)) != NULL) {
|
||||
return G_TYPE_FROM_CLASS(klass);
|
||||
}
|
||||
|
||||
if (DEBUG) {
|
||||
g_warning ("matrix-event-base.vala:243: No registered type for %s", event_type);
|
||||
}
|
||||
|
||||
return G_TYPE_NONE;
|
||||
}
|
||||
|
||||
/**
|
||||
* matrix_event_register_type:
|
||||
* @event_type: (transfer none): the type of the event
|
||||
* @event_gtype: the #GType of the event’s handler
|
||||
* @error: a #GError, or %NULL to ignore errors
|
||||
*
|
||||
* Registers @event_type to be handled by the type @event_gtype.
|
||||
*/
|
||||
void
|
||||
matrix_event_register_type(const gchar *event_type, GType event_gtype, GError **error)
|
||||
{
|
||||
gchar *key;
|
||||
GTypeClass *klass;
|
||||
|
||||
g_return_if_fail(event_type != NULL);
|
||||
|
||||
if (!g_type_is_a (event_gtype, MATRIX_EVENT_TYPE_BASE)) {
|
||||
g_set_error(error, MATRIX_ERROR, MATRIX_ERROR_INVALID_TYPE,
|
||||
"Invalid event type handler. It must be a subclass of MatrixEvent");
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (matrix_event_type_handlers == NULL) {
|
||||
matrix_event_type_handlers = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_type_class_unref);
|
||||
}
|
||||
|
||||
key = g_strdup (event_type);
|
||||
klass = g_type_class_ref (event_gtype);
|
||||
|
||||
g_hash_table_replace(matrix_event_type_handlers, key, klass);
|
||||
}
|
||||
|
||||
/**
|
||||
* matrix_event_unregister_type:
|
||||
* @event_type: (transfer none): the event type to remove
|
||||
*
|
||||
* Unregister @param event_type.
|
||||
*/
|
||||
void
|
||||
matrix_event_unregister_type(const gchar *event_type)
|
||||
{
|
||||
g_return_if_fail(event_type != NULL && matrix_event_type_handlers != NULL);
|
||||
|
||||
g_hash_table_remove (matrix_event_type_handlers, event_type);
|
||||
}
|
||||
59
src/matrix-event-base.h
Normal file
59
src/matrix-event-base.h
Normal file
@ -0,0 +1,59 @@
|
||||
/*
|
||||
* This file is part of matrix-glib-sdk
|
||||
*
|
||||
* matrix-glib-sdk is free software: you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation, either
|
||||
* version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* matrix-glib-sdk 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 Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with matrix-glib-sdk. If not, see
|
||||
* <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef __MATRIX_GLIX_SDK_EVENT_BASE_H__
|
||||
# define __MATRIX_GLIX_SDK_EVENT_BASE_H__
|
||||
|
||||
# include <glib-object.h>
|
||||
# include <json-glib/json-glib.h>
|
||||
|
||||
# define MATRIX_EVENT_TYPE_BASE (matrix_event_base_get_type ())
|
||||
# define MATRIX_EVENT_BASE(o) (G_TYPE_CHECK_INSTANCE_CAST((o), MATRIX_EVENT_TYPE_BASE, MatrixEventBase))
|
||||
# define MATRIX_EVENT_BASE_CLASS(c) (G_TYPE_CHECK_CLASS_CAST((c), MATRIX_EVENT_TYPE_BASE, MatrixEventBaseClass))
|
||||
# define MATRIX_EVENT_IS_BASE(o) (G_TYPE_CHECK_INSTANCE_TYPE((o), MATRIX_EVENT_TYPE_BASE))
|
||||
# define MATRIX_EVENT_IS_BASE_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE((c), MATRIX_EVENT_TYPE_BASE))
|
||||
# define MATRIX_EVENT_BASE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS((o), MATRIX_EVENT_TYPE_BASE, MatrixEventBaseClass))
|
||||
|
||||
typedef struct _MatrixEventBase MatrixEventBase;
|
||||
typedef struct _MatrixEventBaseClass MatrixEventBaseClass;
|
||||
G_DEFINE_AUTOPTR_CLEANUP_FUNC(MatrixEventBase, g_object_unref);
|
||||
|
||||
struct _MatrixEventBase {
|
||||
GObject parent_instance;
|
||||
};
|
||||
|
||||
struct _MatrixEventBaseClass {
|
||||
GObjectClass parent_instance;
|
||||
|
||||
void (*from_json)(MatrixEventBase *matrix_event_base, JsonNode *json_data, GError **error);
|
||||
void (*to_json)(MatrixEventBase *matrix_event_base, JsonNode *json_data, GError **error);
|
||||
};
|
||||
|
||||
GType matrix_event_get_handler(const gchar *event_type);
|
||||
void matrix_event_register_type(const gchar *event_type, GType event_gtype, GError **error);
|
||||
void matrix_event_unregister_type(const gchar *event_type);
|
||||
|
||||
GType matrix_event_base_get_type(void) G_GNUC_CONST;
|
||||
void matrix_event_base_from_json(MatrixEventBase *event, JsonNode *json_data, GError **error);
|
||||
void matrix_event_base_to_json(MatrixEventBase *event, JsonNode *json_data, GError **error);
|
||||
MatrixEventBase *matrix_event_base_new_from_json(const gchar *event_type, JsonNode *json_data, GError **error);
|
||||
MatrixEventBase *matrix_event_base_construct(GType object_type);
|
||||
const gchar *matrix_event_base_get_event_type(MatrixEventBase *event);
|
||||
JsonNode *matrix_event_base_get_json(MatrixEventBase *event);
|
||||
|
||||
#endif /* __MATRIX_GLIX_SDK_EVENT_BASE_H__ */
|
||||
@ -1,285 +0,0 @@
|
||||
/*
|
||||
* This file is part of matrix-glib-sdk
|
||||
*
|
||||
* matrix-glib-sdk is free software: you can redistribute it and/or
|
||||
* modify it under the terms of the GNU Lesser General Public
|
||||
* License as published by the Free Software Foundation, either
|
||||
* version 3 of the License, or (at your option) any later version.
|
||||
*
|
||||
* matrix-glib-sdk 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 Lesser General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU Lesser General Public
|
||||
* License along with matrix-glib-sdk. If not, see
|
||||
* <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/**
|
||||
* Base class for Matrix events.
|
||||
*/
|
||||
public abstract class Matrix.Event.Base : GLib.Object, GLib.Initable {
|
||||
private Error? _construct_error = null;
|
||||
private bool _inited = false;
|
||||
private Json.Node? _json;
|
||||
|
||||
protected string? _event_type = null;
|
||||
|
||||
/**
|
||||
* The type of the event. It should be namespaced similar to the
|
||||
* Java package naming conventions,
|
||||
* e.g. `com.example.subdomain.event.type`. It cannot be changed
|
||||
* after object initialization.
|
||||
*/
|
||||
public string? event_type {
|
||||
get {
|
||||
return _event_type;
|
||||
}
|
||||
|
||||
construct {
|
||||
_event_type = value;
|
||||
}
|
||||
|
||||
default = null;
|
||||
}
|
||||
|
||||
/**
|
||||
* The event as a JSON node.
|
||||
*/
|
||||
public Json.Node? json {
|
||||
get {
|
||||
_json = new Json.Node(Json.NodeType.OBJECT);
|
||||
_json.set_object(new Json.Object());
|
||||
|
||||
// Add the content node, as all event types must include it.
|
||||
var content_root = new Json.Node(Json.NodeType.OBJECT);
|
||||
var content_obj = new Json.Object();
|
||||
content_root.set_object(content_obj);
|
||||
_json.get_object().set_member("content", content_root);
|
||||
|
||||
try {
|
||||
to_json(_json);
|
||||
}
|
||||
catch (Matrix.Error e) {
|
||||
return null;
|
||||
}
|
||||
|
||||
return _json;
|
||||
}
|
||||
|
||||
construct {
|
||||
if (value != null) {
|
||||
try {
|
||||
initialize_from_json(value);
|
||||
} catch (Matrix.Error e) {}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public bool
|
||||
init(GLib.Cancellable? cancellable = null)
|
||||
throws Error, Matrix.Error
|
||||
{
|
||||
if (cancellable != null) {
|
||||
throw new Matrix.Error.UNSUPPORTED(
|
||||
"Cancellable initialization not supported");
|
||||
}
|
||||
|
||||
if (_construct_error != null) {
|
||||
throw _construct_error;
|
||||
}
|
||||
|
||||
_inited = true;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
private void
|
||||
initialize_from_json(Json.Node json_data)
|
||||
throws Matrix.Error
|
||||
{
|
||||
Json.Object root;
|
||||
Json.Node node;
|
||||
|
||||
if (json_data.get_node_type() != Json.NodeType.OBJECT) {
|
||||
throw new Matrix.Error.INVALID_FORMAT(
|
||||
"The event is not valid");
|
||||
}
|
||||
|
||||
root = json_data.get_object();
|
||||
|
||||
if ((node = root.get_member("type")) == null) {
|
||||
throw new Matrix.Error.INCOMPLETE(
|
||||
"Event type is not specified");
|
||||
}
|
||||
|
||||
if ((_event_type != null)
|
||||
&& (_event_type != node.get_string())) {
|
||||
throw new Matrix.Error.INVALID_TYPE(
|
||||
"Changing event type is not supported");
|
||||
}
|
||||
|
||||
var evt_type = node.get_string();
|
||||
|
||||
if ((node = root.get_member("content")) == null) {
|
||||
warning("content key is missing from the %s event", evt_type);
|
||||
|
||||
// As event type objects depend on having this node, let’s
|
||||
// add it now.
|
||||
var content_node = new Json.Node(Json.NodeType.OBJECT);
|
||||
content_node.set_object(new Json.Object());
|
||||
root.set_member("content", content_node);
|
||||
}
|
||||
|
||||
from_json(json_data);
|
||||
|
||||
_event_type = evt_type;
|
||||
}
|
||||
|
||||
/**
|
||||
* Subclasses should implement this function to initialize
|
||||
* themselves from JSON data.
|
||||
*/
|
||||
public virtual void
|
||||
from_json(Json.Node json_data)
|
||||
throws Matrix.Error
|
||||
{
|
||||
var root = json_data.get_object();
|
||||
Json.Node? node;
|
||||
|
||||
if ((node = root.get_member("type")) != null) {
|
||||
_event_type = node.get_string();
|
||||
} else if (Config.DEBUG) {
|
||||
warning("type is not present in an event");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Subclasses should implement this to export their data to JSON.
|
||||
*/
|
||||
public virtual void
|
||||
to_json(Json.Node json_data)
|
||||
throws Matrix.Error
|
||||
{
|
||||
var root = json_data.get_object();
|
||||
|
||||
if (_event_type == null) {
|
||||
throw new Matrix.Error.INCOMPLETE(
|
||||
"Won't generate an event without type");
|
||||
}
|
||||
|
||||
root.set_string_member("type", _event_type);
|
||||
}
|
||||
|
||||
public static Base?
|
||||
new_from_json(owned string? event_type = null,
|
||||
Json.Node? json_data = null)
|
||||
throws Matrix.Error, GLib.Error
|
||||
{
|
||||
GLib.Type? event_gtype;
|
||||
Base? ret = null;
|
||||
|
||||
if (event_type == null) {
|
||||
if (json_data == null) {
|
||||
throw new Matrix.Error.INCOMPLETE(
|
||||
"Either event_type or json_data must be set!");
|
||||
}
|
||||
|
||||
if (json_data.get_node_type() != Json.NodeType.OBJECT) {
|
||||
throw new Matrix.Error.INVALID_FORMAT(
|
||||
"Event is not a JSON object!");
|
||||
}
|
||||
|
||||
Json.Node? node;
|
||||
|
||||
if ((node = json_data.get_object().get_member("type")) == null) {
|
||||
throw new Matrix.Error.INCOMPLETE(
|
||||
"event_type is null and JSON object doesn't contain type!");
|
||||
}
|
||||
|
||||
event_type = node.get_string();
|
||||
}
|
||||
|
||||
if ((event_gtype = get_handler(event_type)) == null) {
|
||||
throw new Matrix.Error.INVALID_TYPE(
|
||||
"No registered type for event type %s",
|
||||
event_type);
|
||||
}
|
||||
|
||||
ret = (Base)Object.new(event_gtype,
|
||||
event_type : event_type,
|
||||
json : json_data);
|
||||
|
||||
ret.init();
|
||||
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
namespace Matrix.Event {
|
||||
|
||||
private HashTable<string, TypeClass>? type_handlers = null;
|
||||
|
||||
/**
|
||||
* Get the {@link GLib.Type} of the class that is registered to
|
||||
* handle events with type @param event_type.
|
||||
*
|
||||
* @param event_type the event type to look up
|
||||
* @return a {@link GLib.Type} or {@link Matrix.Event} if no
|
||||
* handler is registered
|
||||
*/
|
||||
public static GLib.Type?
|
||||
get_handler(string event_type)
|
||||
{
|
||||
unowned GLib.TypeClass? klass = null;
|
||||
|
||||
if ((type_handlers != null)
|
||||
&& ((klass = type_handlers.get(event_type)) != null)) {
|
||||
return klass.get_type();
|
||||
}
|
||||
|
||||
if (Config.DEBUG) {
|
||||
warning("No registered type for %s", event_type);
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Registers @param event_type to be handled by the
|
||||
* type @param event_gtype.
|
||||
*
|
||||
* @param event_type the type of the event
|
||||
* @param event_gtype the {@link GLib.Type} of the event’s handler
|
||||
*/
|
||||
public static void
|
||||
register_type(string event_type, GLib.Type event_gtype)
|
||||
throws Matrix.Error
|
||||
{
|
||||
if (!event_gtype.is_a(typeof(Matrix.Event.Base))) {
|
||||
throw new Matrix.Error.INVALID_TYPE(
|
||||
"Invalid event type handler. It must be a subclass of MatrixEvent");
|
||||
}
|
||||
|
||||
if (type_handlers == null) {
|
||||
type_handlers = new HashTable<string, GLib.TypeClass>(
|
||||
str_hash, str_equal);
|
||||
}
|
||||
|
||||
type_handlers.replace(event_type, event_gtype.class_ref());
|
||||
}
|
||||
|
||||
/**
|
||||
* Unregister @param event_type.
|
||||
*
|
||||
* @param event_type the event type to remove
|
||||
*/
|
||||
public static void
|
||||
unregister_type(string event_type)
|
||||
{
|
||||
if (type_handlers != null) {
|
||||
type_handlers.remove(event_type);
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -456,4 +456,38 @@ namespace Matrix {
|
||||
public bool glib_check_version(uint required_major,
|
||||
uint required_minor,
|
||||
uint required_micro);
|
||||
|
||||
[CCode (gir_namespace = "MatrixEvent", gir_version = "0.0")]
|
||||
namespace Event {
|
||||
[CCode (cheader_filename = "matrix-event-base.h")]
|
||||
public abstract class Base : GLib.Object, GLib.Initable {
|
||||
protected string? _event_type;
|
||||
public string? event_type { get; construct; default = null; }
|
||||
public Json.Node? json { get; set; default = null; }
|
||||
|
||||
public Base();
|
||||
|
||||
public bool init(GLib.Cancellable? cancellable = null)
|
||||
throws Error, Matrix.Error;
|
||||
|
||||
public virtual void from_json(Json.Node json_data)
|
||||
throws Matrix.Error;
|
||||
|
||||
public virtual void to_json(Json.Node json_data)
|
||||
throws Matrix.Error;
|
||||
|
||||
public static Base? new_from_json(owned string? event_type = null, Json.Node? json_data = null)
|
||||
throws Matrix.Error, GLib.Error;
|
||||
}
|
||||
|
||||
[CCode (cheader_filename = "matrix-event-base.h")]
|
||||
public static GLib.Type? get_handler(string event_type);
|
||||
|
||||
[CCode (cheader_filename = "matrix-event-base.h")]
|
||||
public static void register_type(string event_type, GLib.Type event_gtype)
|
||||
throws Matrix.Error;
|
||||
|
||||
[CCode (cheader_filename = "matrix-event-base.h")]
|
||||
public static void unregister_type(string event_type);
|
||||
}
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user