dom.c

   1 /*
   2 Calf Box, an open source musical instrument.
   3 Copyright (C) 2012 Krzysztof Foltman
   4
   5 This program is free software: you can redistribute it and/or modify
   6 it under the terms of the GNU General Public License as published by
   7 the Free Software Foundation, either version 3 of the License, or
   8 (at your option) any later version.
   9
  10 This program is distributed in the hope that it will be useful,
  11 but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17 */
  18
  19 #include "cmd.h"
  20 #include "errors.h"
  21 #include "dom.h"
  22
  23 #include <assert.h>
  24 #include <glib.h>
  25 #include <malloc.h>
  26 #include <string.h>
  27
  28 static GHashTable *class_name_hash = NULL;
  29
  30 struct cbox_class_per_document
  31 {
  32     GList *instances;
  33 };
  34
  35 struct cbox_document
  36 {
  37     GHashTable *classes_per_document;
  38     GHashTable *services_per_document;
  39     GHashTable *uuids_per_document;
  40     struct cbox_command_target cmd_target;
  41     int item_ctr;
  42 };
  43
  44 ////////////////////////////////////////////////////////////////////////////////////////
  45
  46 void cbox_dom_init()
  47 {
  48     class_name_hash = g_hash_table_new(g_str_hash, g_str_equal);
  49 }
  50
  51 void cbox_dom_close()
  52 {
  53     g_hash_table_destroy(class_name_hash);
  54 }
  55
  56 ////////////////////////////////////////////////////////////////////////////////////////
  57
  58 struct cbox_class *cbox_class_find_by_name(const char *name)
  59 {
  60     assert(class_name_hash != NULL);
  61     return g_hash_table_lookup(class_name_hash, name);
  62 }
  63
  64 void cbox_class_register(struct cbox_class *class_ptr)
  65 {
  66     assert(class_name_hash != NULL);
  67     g_hash_table_insert(class_name_hash, (gpointer)class_ptr->name, class_ptr);
  68 }
  69
  70 static struct cbox_class_per_document *get_cpd_for_class(struct cbox_document *doc, struct cbox_class *class_ptr)
  71 {
  72     struct cbox_class_per_document *p = g_hash_table_lookup(doc->classes_per_document, class_ptr);
  73     if (p != NULL)
  74         return p;
  75     p = malloc(sizeof(struct cbox_class_per_document));
  76     p->instances = NULL;
  77     g_hash_table_insert(doc->classes_per_document, class_ptr, p);
  78     return p;
  79 }
  80
  81 ////////////////////////////////////////////////////////////////////////////////////////
  82
  83 guint cbox_uuid_hash(gconstpointer v)
  84 {
  85     char buf[40];
  86     uuid_unparse_lower(((struct cbox_uuid *)v)->uuid, buf);
  87     return g_str_hash(buf);
  88 }
  89
  90 gboolean cbox_uuid_equal(gconstpointer v1, gconstpointer v2)
  91 {
  92     const struct cbox_uuid *p1 = v1;
  93     const struct cbox_uuid *p2 = v2;
  94
  95     return !uuid_compare(p1->uuid, p2->uuid);
  96 }
  97
  98 gboolean cbox_uuid_report_as(struct cbox_uuid *uuid, const char *cmd, struct cbox_command_target *fb, GError **error)
  99 {
 100     if (!fb)
 101         return TRUE;
 102     return cbox_execute_on(fb, NULL, cmd, "u", error, uuid->uuid);
 103 }
 104
 105 gboolean cbox_uuid_report(struct cbox_uuid *uuid, struct cbox_command_target *fb, GError **error)
 106 {
 107     return cbox_uuid_report_as(uuid, "/uuid", fb, error);
 108 }
 109
 110 gboolean cbox_uuid_fromstring(struct cbox_uuid *uuid, const char *str, GError **error)
 111 {
 112     if (uuid_parse(str, uuid->uuid))
 113     {
 114         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Malformed UUID: '%s'", str);
 115         return FALSE;
 116     }
 117     return TRUE;
 118 }
 119
 120 void cbox_uuid_tostring(struct cbox_uuid *uuid, char str[40])
 121 {
 122     uuid_unparse(uuid->uuid, str);
 123 }
 124
 125 void cbox_uuid_generate(struct cbox_uuid *uuid)
 126 {
 127     uuid_generate(uuid->uuid);
 128 }
 129
 130 ////////////////////////////////////////////////////////////////////////////////////////
 131
 132 void cbox_object_register_instance(struct cbox_document *doc, struct cbox_objhdr *obj)
 133 {
 134     assert(obj != NULL);
 135
 136     struct cbox_class_per_document *cpd = get_cpd_for_class(doc, obj->class_ptr);
 137     cpd->instances = g_list_prepend(cpd->instances, obj);
 138     obj->owner = doc;
 139     obj->link_in_document = cpd->instances;
 140     g_hash_table_insert(obj->owner->uuids_per_document, &obj->instance_uuid, obj);
 141 }
 142
 143 struct cbox_command_target *cbox_object_get_cmd_target(struct cbox_objhdr *hdr_ptr)
 144 {
 145     if (!hdr_ptr->class_ptr->getcmdtargetfunc)
 146         return NULL;
 147     return hdr_ptr->class_ptr->getcmdtargetfunc(hdr_ptr);
 148 }
 149
 150 gboolean cbox_object_try_default_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, const char *subcmd, gboolean *result, GError **error)
 151 {
 152     // XXXKF this assumes objhdr ptr == object ptr - needs to add the header offset in cmd target?
 153     struct cbox_objhdr *obj = ct->user_data;
 154     if (!strcmp(subcmd, "/status") && !strcmp(cmd->arg_types, ""))
 155     {
 156         if (!cbox_object_default_status(obj, fb, error))
 157         {
 158             *result = FALSE;
 159             return TRUE;
 160         }
 161         return FALSE;
 162     }
 163     if (!strcmp(subcmd, "/delete") && !strcmp(cmd->arg_types, ""))
 164     {
 165         cbox_object_destroy(obj);
 166         *result = TRUE;
 167         return TRUE;
 168     }
 169     if (!strcmp(subcmd, "/get_uuid") && !strcmp(cmd->arg_types, ""))
 170     {
 171         if (!cbox_check_fb_channel(fb, cmd->command, error))
 172         {
 173             *result = FALSE;
 174             return TRUE;
 175         }
 176
 177         *result = cbox_uuid_report(&obj->instance_uuid, fb, error);
 178         return TRUE;
 179     }
 180     if (!strcmp(subcmd, "/get_class_name") && !strcmp(cmd->arg_types, ""))
 181     {
 182         if (!cbox_check_fb_channel(fb, cmd->command, error))
 183         {
 184             *result = FALSE;
 185             return TRUE;
 186         }
 187         *result = cbox_execute_on(fb, NULL, "/class_name", "s", error, obj->class_ptr->name);
 188         return TRUE;
 189     }
 190     return FALSE;
 191 }
 192
 193 gboolean cbox_object_default_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
 194 {
 195     gboolean result = FALSE;
 196     if (cbox_object_try_default_process_cmd(ct, fb, cmd, cmd->command, &result, error))
 197         return result;
 198     struct cbox_objhdr *obj = ct->user_data;
 199     g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Unknown combination of target path and argument: '%s', '%s' for object class '%s'", cmd->command, cmd->arg_types, obj->class_ptr->name);
 200     return FALSE;
 201 }
 202
 203 gboolean cbox_object_default_status(struct cbox_objhdr *objhdr, struct cbox_command_target *fb, GError **error)
 204 {
 205     char buf[40];
 206     uuid_unparse(objhdr->instance_uuid.uuid, buf);
 207     return cbox_execute_on(fb, NULL, "/uuid", "s", error, buf);
 208 }
 209
 210 void cbox_object_destroy(struct cbox_objhdr *hdr_ptr)
 211 {
 212     struct cbox_class_per_document *cpd = get_cpd_for_class(hdr_ptr->owner, hdr_ptr->class_ptr);
 213     cpd->instances = g_list_remove_link(cpd->instances, hdr_ptr->link_in_document);
 214     hdr_ptr->link_in_document = NULL;
 215     g_hash_table_remove(hdr_ptr->owner->uuids_per_document, &hdr_ptr->instance_uuid);
 216
 217     hdr_ptr->class_ptr->destroyfunc(hdr_ptr);
 218 }
 219
 220 ////////////////////////////////////////////////////////////////////////////////////////
 221
 222 static gboolean document_process_cmd(struct cbox_command_target *ct, struct cbox_command_target *fb, struct cbox_osc_command *cmd, GError **error)
 223 {
 224     char *uuid;
 225     const char *subcommand;
 226     if (!strcmp(cmd->command, "/dump") && !strcmp(cmd->arg_types, ""))
 227     {
 228         struct cbox_document *doc = ct->user_data;
 229         cbox_document_dump(doc);
 230         return TRUE;
 231     }
 232     if (cbox_parse_path_part_str(cmd, "/uuid/", &subcommand, &uuid, error))
 233     {
 234         struct cbox_document *doc = ct->user_data;
 235         if (!subcommand)
 236             return FALSE;
 237         struct cbox_objhdr *obj = cbox_document_get_object_by_text_uuid(doc, uuid, NULL, error);
 238         g_free(uuid);
 239         if (!obj)
 240             return FALSE;
 241         struct cbox_command_target *ct2 = cbox_object_get_cmd_target(obj);
 242         return cbox_execute_sub(ct2, fb, cmd, subcommand, error);
 243     }
 244     g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Unknown combination of target path and argument: '%s', '%s'", cmd->command, cmd->arg_types);
 245     return FALSE;
 246 }
 247
 248 struct cbox_document *cbox_document_new()
 249 {
 250     struct cbox_document *res = malloc(sizeof(struct cbox_document));
 251     res->classes_per_document = g_hash_table_new_full(NULL, NULL, NULL, g_free);
 252     res->services_per_document = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
 253     res->uuids_per_document = g_hash_table_new(cbox_uuid_hash, cbox_uuid_equal);
 254     res->cmd_target.process_cmd = document_process_cmd;
 255     res->cmd_target.user_data = res;
 256     res->item_ctr = 0;
 257
 258     return res;
 259 }
 260
 261 struct cbox_command_target *cbox_document_get_cmd_target(struct cbox_document *doc)
 262 {
 263     return &doc->cmd_target;
 264 }
 265
 266 struct cbox_objhdr *cbox_document_get_service(struct cbox_document *document, const char *name)
 267 {
 268     return g_hash_table_lookup(document->services_per_document, name);
 269 }
 270
 271 void cbox_document_set_service(struct cbox_document *document, const char *name, struct cbox_objhdr *obj)
 272 {
 273     g_hash_table_insert(document->services_per_document, g_strdup(name), obj);
 274 }
 275
 276 struct cbox_objhdr *cbox_document_get_object_by_uuid(struct cbox_document *doc, const struct cbox_uuid *uuid)
 277 {
 278     return g_hash_table_lookup(doc->uuids_per_document, uuid);
 279 }
 280
 281 struct cbox_objhdr *cbox_document_get_object_by_text_uuid(struct cbox_document *doc, const char *uuid, const struct cbox_class *class_ptr, GError **error)
 282 {
 283     struct cbox_uuid uuidv;
 284     if (!cbox_uuid_fromstring(&uuidv, uuid, error))
 285         return NULL;
 286     struct cbox_objhdr *obj = cbox_document_get_object_by_uuid(doc, &uuidv);
 287     if (!obj)
 288     {
 289         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "UUID not found: '%s'", uuid);
 290         return NULL;
 291     }
 292     if (class_ptr && !cbox_class_is_a(obj->class_ptr, class_ptr))
 293     {
 294         g_set_error(error, CBOX_MODULE_ERROR, CBOX_MODULE_ERROR_FAILED, "Unexpected object type '%s' for UUID '%s' (expected '%s')", obj->class_ptr->name, uuid, class_ptr->name);
 295         return NULL;
 296     }
 297     return obj;
 298 }
 299
 300 static void iter_func(gpointer key, gpointer value, gpointer doc_)
 301 {
 302 #ifndef NDEBUG
 303     struct cbox_document *doc = (struct cbox_document *)doc_;
 304 #endif
 305     struct cbox_class *class_ptr = key;
 306     struct cbox_class_per_document *cpd = value;
 307     int first = 1;
 308     printf("Class %s: ", class_ptr->name);
 309     GList *l = cpd->instances;
 310     while(l) {
 311         if (!first)
 312             printf(", ");
 313         printf("%p", l->data);
 314         fflush(stdout);
 315         struct cbox_objhdr *hdr = (struct cbox_objhdr *)l->data;
 316         char buf[40];
 317         uuid_unparse(hdr->instance_uuid.uuid, buf);
 318         printf("[%s]", buf);
 319         fflush(stdout);
 320         assert(cbox_document_get_object_by_uuid(doc, &hdr->instance_uuid));
 321         l = l->next;
 322         first = 0;
 323     }
 324     if (first)
 325         printf("<no instances>");
 326     printf("\n");
 327 }
 328
 329 static void iter_func2(gpointer key, gpointer value, gpointer document)
 330 {
 331     struct cbox_objhdr *oh = value;
 332     char buf[40];
 333     uuid_unparse(oh->instance_uuid.uuid, buf);
 334     printf("Service %s: %p", (const char *)key, value);
 335     fflush(stdout);
 336     printf("[%s]", buf);
 337     fflush(stdout);
 338     printf(" (%s)\n", oh->class_ptr->name);
 339 }
 340
 341 void cbox_document_dump(struct cbox_document *document)
 342 {
 343      g_hash_table_foreach(document->classes_per_document, iter_func, document);
 344      g_hash_table_foreach(document->services_per_document, iter_func2, document);
 345 }
 346
 347 void cbox_document_destroy(struct cbox_document *document)
 348 {
 349     g_hash_table_destroy(document->classes_per_document);
 350     g_hash_table_destroy(document->services_per_document);
 351     g_hash_table_destroy(document->uuids_per_document);
 352     free(document);
 353 }
 354
 355