/* -*- mode: C; c-file-style: "gnu" -*- */

 /* dbus-gidl.c data structure describing an interface, to be generated from IDL

  *             or something

  *

  * Copyright (C) 2003, 2005  Red Hat, Inc.

  * Portion Copyright © 2008 Nokia Corporation and/or its subsidiary(-ies). All rights reserved.

  * Licensed under the Academic Free License version 2.1

  *

  * This program is free software; you can redistribute it and/or modify

  * it under the terms of the GNU General Public License as published by

  * the Free Software Foundation; either version 2 of the License, or

  * (at your option) any later version.

  *

  * This program is distributed in the hope that it will be useful,

  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  * GNU General Public License for more details.

  *

  * You should have received a copy of the GNU General Public License

  * along with this program; if not, write to the Free Software

  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

  *

  */

 #include "dbus-gidl.h"

 #ifndef DOXYGEN_SHOULD_SKIP_THIS

 struct BaseInfo

 {

   unsigned int refcount : 28;

   unsigned int type     : 4;

   char *name;

 };

 struct NodeInfo

 {

   BaseInfo base;

   GSList *interfaces;

   GSList *nodes;

 };

 struct InterfaceInfo

 {

   BaseInfo base;

   GHashTable *annotations;

   /* Since we have BaseInfo now these could be one list */

   GSList *methods;

   GSList *signals;

   GSList *properties;

 };

 struct MethodInfo

 {

   BaseInfo base;

   GHashTable *annotations;

   GSList *args;

 };

 struct SignalInfo

 {

   BaseInfo base;

   GSList *args;

 };

 struct PropertyInfo

 {

   BaseInfo base;

   char *type;

   PropertyAccessFlags access;

 };

 struct ArgInfo

 {

   BaseInfo base;

   char *type;

   ArgDirection direction;

   GHashTable *annotations;

 };

 static void

 get_hash_key (gpointer key, gpointer value, gpointer data)

 {

   GSList **list = data;

   *list = g_slist_prepend (*list, key);

 }

 static GSList *

 get_hash_keys (GHashTable *table)

 {

   GSList *ret = NULL;

   g_hash_table_foreach (table, get_hash_key, &ret);

   return ret;

 }

 BaseInfo *

 base_info_ref (BaseInfo *info)

 {

   g_return_val_if_fail (info != NULL, NULL);

   g_return_val_if_fail (info->refcount > 0, NULL);

   info->refcount += 1;

   return info;

 }

 static void

 base_info_free (void *ptr)

 {

   BaseInfo *info;

   info = ptr;

   g_free (info->name);

   g_free (info);

 }

 void

 base_info_unref (BaseInfo *info)

 {

   g_return_if_fail (info != NULL);

   g_return_if_fail (info->refcount > 0);

   /* This is sort of bizarre, BaseInfo was tacked on later */

   switch (info->type)

     {

     case INFO_TYPE_NODE:

       node_info_unref ((NodeInfo*) info);

       break;

     case INFO_TYPE_INTERFACE:

       interface_info_unref ((InterfaceInfo*) info);

       break;

     case INFO_TYPE_SIGNAL:

       signal_info_unref ((SignalInfo*) info);

       break;

     case INFO_TYPE_METHOD:

       method_info_unref ((MethodInfo*) info);

       break;

     case INFO_TYPE_PROPERTY:

       property_info_unref ((PropertyInfo*) info);

       break;

     case INFO_TYPE_ARG:

       arg_info_unref ((ArgInfo*) info);

       break;

     }

 }

 InfoType

 base_info_get_type (BaseInfo      *info)

 {

   return info->type;

 }

 const char*

 base_info_get_name (BaseInfo *info)

 {

   return info->name;

 }

 void

 base_info_set_name (BaseInfo      *info,

                     const char    *name)

 {

   char *old;

   old = info->name;

   info->name = g_strdup (name);

   g_free (old);

 }

 GType

 base_info_get_gtype (void)

 {

   #if EMULATOR

 GET_STATIC_VAR_FROM_TLS(out_type,dbus_gidl,GType )

 #define our_type (*GET_DBUS_WSD_VAR_NAME(our_type,dbus_gidl,s)())

 #else

   static GType our_type = 0;

 #endif

   if (our_type == 0)

     our_type = g_boxed_type_register_static ("BaseInfo",

                                              (GBoxedCopyFunc) base_info_ref,

                                              (GBoxedFreeFunc) base_info_unref);

   return our_type;

 }

 static void

 free_interface_list (GSList **interfaces_p)

 {

   GSList *tmp;

   tmp = *interfaces_p;

   while (tmp != NULL)

     {

       interface_info_unref (tmp->data);

       tmp = tmp->next;

     }

   g_slist_free (*interfaces_p);

   *interfaces_p = NULL;

 }

 static void

 free_node_list (GSList **nodes_p)

 {

   GSList *tmp;

   tmp = *nodes_p;

   while (tmp != NULL)

     {

       node_info_unref (tmp->data);

       tmp = tmp->next;

     }

   g_slist_free (*nodes_p);

   *nodes_p = NULL;

 }

 static void

 free_method_list (GSList **methods_p)

 {

   GSList *tmp;

   tmp = *methods_p;

   while (tmp != NULL)

     {

       method_info_unref (tmp->data);

       tmp = tmp->next;

     }

   g_slist_free (*methods_p);

   *methods_p = NULL;

 }

 static void

 free_signal_list (GSList **signals_p)

 {

   GSList *tmp;

   tmp = *signals_p;

   while (tmp != NULL)

     {

       signal_info_unref (tmp->data);

       tmp = tmp->next;

     }

   g_slist_free (*signals_p);

   *signals_p = NULL;

 }

 static void

 free_property_list (GSList **props_p)

 {

   GSList *tmp;

   tmp = *props_p;

   while (tmp != NULL)

     {

       property_info_unref (tmp->data);

       tmp = tmp->next;

     }

   g_slist_free (*props_p);

   *props_p = NULL;

 }

 NodeInfo*

 node_info_new (const char *name)

 {

   NodeInfo *info;

   /* name can be NULL */

   info = g_new0 (NodeInfo, 1);

   info->base.refcount = 1;

   info->base.name = g_strdup (name);

   info->base.type = INFO_TYPE_NODE;

   return info;

 }

 NodeInfo *

 node_info_ref (NodeInfo *info)

 {

   info->base.refcount += 1;

   return info;

 }

 void

 node_info_unref (NodeInfo *info)

 {

   info->base.refcount -= 1;

   if (info->base.refcount == 0)

     {

       free_interface_list (&info->interfaces);

       free_node_list (&info->nodes);

       base_info_free (info);

     }

 }

 const char*

 node_info_get_name (NodeInfo *info)

 {

   return info->base.name;

 }

 GSList*

 node_info_get_interfaces (NodeInfo *info)

 {

   return info->interfaces;

 }

 void

 node_info_add_interface (NodeInfo *info,

                          InterfaceInfo    *interface)

 {

   interface_info_ref (interface);

   info->interfaces = g_slist_append (info->interfaces, interface);

 }

 GSList*

 node_info_get_nodes (NodeInfo *info)

 {

   return info->nodes;

 }

 void

 node_info_add_node (NodeInfo *info,

                     NodeInfo *node)

 {

   node_info_ref (node);

   info->nodes = g_slist_append (info->nodes, node);

 }

 void

 node_info_replace_node (NodeInfo            *info,

                         NodeInfo            *old_child,

                         NodeInfo            *new_child)

 {

   GSList *link;

   node_info_ref (new_child); /* before unref old_child in case they are the same */

   link = g_slist_find (info->nodes, old_child);

   g_assert (link != NULL);

   node_info_unref (old_child);

   link->data = new_child;

 }

 InterfaceInfo*

 interface_info_new (const char *name)

 {

   InterfaceInfo *info;

   info = g_new0 (InterfaceInfo, 1);

   info->base.refcount = 1;

   info->base.name = g_strdup (name);

   info->base.type = INFO_TYPE_INTERFACE;

   info->annotations = g_hash_table_new_full (g_str_hash, g_str_equal,

 					     (GDestroyNotify) g_free,

 					     (GDestroyNotify) g_free);

   return info;

 }

 InterfaceInfo *

 interface_info_ref (InterfaceInfo *info)

 {

   info->base.refcount += 1;

   return info;

 }

 void

 interface_info_unref (InterfaceInfo *info)

 {

   info->base.refcount -= 1;

   if (info->base.refcount == 0)

     {

       g_hash_table_destroy (info->annotations);

       free_method_list (&info->methods);

       free_signal_list (&info->signals);

       free_property_list (&info->properties);

       base_info_free (info);

     }

 }

 const char*

 interface_info_get_name (InterfaceInfo *info)

 {

   return info->base.name;

 }

 GSList *

 interface_info_get_annotations (InterfaceInfo *info)

 {

   return get_hash_keys (info->annotations);

 }

 const char*

 interface_info_get_annotation (InterfaceInfo *info,

 			       const char    *name)

 {

   return g_hash_table_lookup (info->annotations, name);

 }

 GSList*

 interface_info_get_methods (InterfaceInfo *info)

 {

   return info->methods;

 }

 GSList*

 interface_info_get_signals (InterfaceInfo *info)

 {

   return info->signals;

 }

 GSList*

 interface_info_get_properties (InterfaceInfo *info)

 {

   return info->properties;

 }

 void

 interface_info_add_annotation (InterfaceInfo *info,

 			       const char    *name,

 			       const char    *value)

 {

   g_hash_table_insert (info->annotations,

 		       g_strdup (name),

 		       g_strdup (value));

 }

 void

 interface_info_add_method (InterfaceInfo *info,

                            MethodInfo    *method)

 {

   method_info_ref (method);

   info->methods = g_slist_append (info->methods, method);

 }

 void

 interface_info_add_signal (InterfaceInfo *info,

                            SignalInfo    *signal)

 {

   signal_info_ref (signal);

   info->signals = g_slist_append (info->signals, signal);

 }

 void

 interface_info_add_property (InterfaceInfo *info,

                              PropertyInfo  *property)

 {

   property_info_ref (property);

   info->properties = g_slist_append (info->properties, property);

 }

 static void

 free_arg_list (GSList **args_p)

 {

   GSList *tmp;

   tmp = *args_p;

   while (tmp != NULL)

     {

       ArgInfo *ai = tmp->data;

       g_assert (ai->base.type == INFO_TYPE_ARG);

       arg_info_unref (tmp->data);

       tmp = tmp->next;

     }

   g_slist_free (*args_p);

   *args_p = NULL;

 }

 MethodInfo*

 method_info_new (const char *name)

 {

   MethodInfo *info;

   info = g_new0 (MethodInfo, 1);

   info->base.refcount = 1;

   info->base.name = g_strdup (name);

   info->base.type = INFO_TYPE_METHOD;

   info->annotations = g_hash_table_new_full (g_str_hash, g_str_equal,

 					  (GDestroyNotify) g_free,

 					  (GDestroyNotify) g_free);

   return info;

 }

 MethodInfo *

 method_info_ref (MethodInfo *info)

 {

   info->base.refcount += 1;

   return info;

 }

 void

 method_info_unref (MethodInfo *info)

 {

   info->base.refcount -= 1;

   if (info->base.refcount == 0)

     {

       g_hash_table_destroy (info->annotations);

       free_arg_list (&info->args);

       base_info_free (info);

     }

 }

 const char*

 method_info_get_name (MethodInfo *info)

 {

   return info->base.name;

 }

 GSList *

 method_info_get_annotations (MethodInfo *info)

 {

   return get_hash_keys (info->annotations);

 }

 const char*

 method_info_get_annotation (MethodInfo *info,

 			    const char *name)

 {

   return g_hash_table_lookup (info->annotations, name);

 }

 GSList*

 method_info_get_args (MethodInfo *info)

 {

   return info->args;

 }

 int

 method_info_get_n_args (MethodInfo *info)

 {

   return g_slist_length (info->args);

 }

 static int

 args_sort_by_direction (const void *a,

                         const void *b)

 {

   const ArgInfo *arg_a = a;

   const ArgInfo *arg_b = b;

   if (arg_a->direction == arg_b->direction)

     return 0;

   else if (arg_a->direction == ARG_IN)

     return -1; /* in is less than out */

   else

     return 1;

 }                  

 void

 method_info_add_annotation (MethodInfo  *info,

 			    const char  *name,

 			    const char  *value)

 {

   g_hash_table_insert (info->annotations,

 		       g_strdup (name),

 		       g_strdup (value));

 }

 void

 method_info_add_arg (MethodInfo    *info,

                      ArgInfo       *arg)

 {

   arg_info_ref (arg);

   info->args = g_slist_append (info->args, arg);

   /* Keep "in" args sorted before "out" and otherwise maintain

    * stable order (g_slist_sort is stable, at least in sufficiently

    * new glib)

    */

   info->args = g_slist_sort (info->args, args_sort_by_direction);

 }

 SignalInfo*

 signal_info_new (const char *name)

 {

   SignalInfo *info;

   info = g_new0 (SignalInfo, 1);

   info->base.refcount = 1;

   info->base.name = g_strdup (name);

   info->base.type = INFO_TYPE_SIGNAL;

   return info;

 }

 SignalInfo *

 signal_info_ref (SignalInfo *info)

 {

   info->base.refcount += 1;

   return info;

 }

 void

 signal_info_unref (SignalInfo *info)

 {

   info->base.refcount -= 1;

   if (info->base.refcount == 0)

     {

       free_arg_list (&info->args);

       base_info_free (info);

     }

 }

 const char*

 signal_info_get_name (SignalInfo *info)

 {

   return info->base.name;

 }

 GSList*

 signal_info_get_args (SignalInfo *info)

 {

   return info->args;

 }

 int

 signal_info_get_n_args (SignalInfo *info)

 {

   return g_slist_length (info->args);

 }

 void

 signal_info_add_arg (SignalInfo    *info,

                      ArgInfo       *arg)

 {

   g_assert (arg->direction == ARG_OUT);

   arg_info_ref (arg);

   info->args = g_slist_append (info->args, arg);

   /* signal args don't need sorting since only "out" is allowed */

 }

 PropertyInfo*

 property_info_new (const char          *name,

                    const char          *type,

                    PropertyAccessFlags  access)

 {

   PropertyInfo *info;

   info = g_new0 (PropertyInfo, 1);

   info->base.refcount = 1;

   info->base.name = g_strdup (name);

   info->base.type = INFO_TYPE_PROPERTY;

   info->type = g_strdup (type);

   info->access = access;

   return info;

 }

 PropertyInfo*

 property_info_ref (PropertyInfo *info)

 {

   info->base.refcount += 1;

   return info;

 }

 void

 property_info_unref (PropertyInfo *info)

 {

   info->base.refcount -= 1;

   if (info->base.refcount == 0)

     {

       g_free (info->type);

       base_info_free (info);

     }

 }

 const char*

 property_info_get_name (PropertyInfo *info)

 {

   return info->base.name;

 }

 const char *

 property_info_get_type (PropertyInfo *info)

 {

   return info->type;

 }

 PropertyAccessFlags

 property_info_get_access (PropertyInfo *info)

 {

   return info->access;

 }

 ArgInfo*

 arg_info_new (const char  *name,

               ArgDirection direction,

               const char  *type)

 {

   ArgInfo *info;

   info = g_new0 (ArgInfo, 1);

   info->base.refcount = 1;

   info->base.type = INFO_TYPE_ARG;

   /* name can be NULL */

   info->base.name = g_strdup (name);

   info->direction = direction;

   info->type = g_strdup (type);

   info->annotations = g_hash_table_new_full (g_str_hash, g_str_equal,

 					     (GDestroyNotify) g_free,

 					     (GDestroyNotify) g_free);

   return info;

 }

 ArgInfo *

 arg_info_ref (ArgInfo *info)

 {

   info->base.refcount += 1;

   return info;

 }

 void

 arg_info_unref (ArgInfo *info)

 {

   info->base.refcount -= 1;

   if (info->base.refcount == 0)

     {

       g_hash_table_destroy (info->annotations);

       g_free (info->type);

       base_info_free (info);

     }

 }

 const char*

 arg_info_get_name (ArgInfo *info)

 {

   return info->base.name;

 }

 const char *

 arg_info_get_type (ArgInfo *info)

 {

   return info->type;

 }

 ArgDirection

 arg_info_get_direction (ArgInfo *info)

 {

   return info->direction;

 }

 GSList*

 arg_info_get_annotations (ArgInfo *info)

 {

   return get_hash_keys (info->annotations);

 }

 const char*

 arg_info_get_annotation (ArgInfo    *info,

 			 const char *annotation)

 {

   return g_hash_table_lookup (info->annotations, annotation);

 }

 void

 arg_info_add_annotation (ArgInfo             *info,

 			 const char          *name,

 			 const char          *value)

 {

   g_hash_table_insert (info->annotations,

 		       g_strdup (name),

 		       g_strdup (value));

 }

 #ifdef DBUS_BUILD_TESTS

 /**

  * @ingroup DBusGIDL

  * Unit test for GLib IDL internals

  * Returns: #TRUE on success.

  */

 gboolean

 _dbus_gidl_test (void)

 {

   return TRUE;

 }

 #endif /* DBUS_BUILD_TESTS */

 #endif /* DOXYGEN_SHOULD_SKIP_THIS */