plugins/symbol-db/symbol-db-engine-iterator-node.c

   1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 4; tab-width: 4 -*- */
   2 /*
   3  * anjuta
   4  * Copyright (C) Massimo Cora' 2007 <maxcvs@email.it>
   5  *
   6  * anjuta is free software.
   7  *
   8  * You may redistribute it and/or modify it under the terms of the
   9  * GNU General Public License, as published by the Free Software
  10  * Foundation; either version 2 of the License, or (at your option)
  11  * any later version.
  12  *
  13  * anjuta is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  16  * See the GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with anjuta.  If not, write to:
  20  *      The Free Software Foundation, Inc.,
  21  *      51 Franklin Street, Fifth Floor
  22  *      Boston, MA  02110-1301, USA.
  23  */
  24
  25 #include <libanjuta/interfaces/ianjuta-symbol.h>
  26 #include <libanjuta/anjuta-utils.h>
  27 #include <libanjuta/anjuta-debug.h>
  28
  29 #include "symbol-db-engine-iterator-node.h"
  30 #include "symbol-db-engine.h"
  31 #include "symbol-db-view.h"
  32
  33 struct _SymbolDBEngineIteratorNodePriv
  34 {
  35         GdaDataModelIter *data_iter;
  36         const GHashTable *sym_type_conversion_hash;
  37         gchar *uri;
  38 };
  39
  40 static GObjectClass* parent_class = NULL;
  41
  42
  43 SymbolDBEngineIteratorNode *
  44 symbol_db_engine_iterator_node_new (const GdaDataModelIter *data)
  45 {
  46 /*      DEBUG_PRINT ("sdb_engine_iterator_node_new ()");*/
  47         SymbolDBEngineIteratorNode *s;
  48         s = g_object_new (SYMBOL_TYPE_DB_ENGINE_ITERATOR_NODE, NULL);
  49         s->priv->data_iter = (GdaDataModelIter *)data;
  50         s->priv->uri = NULL;
  51
  52         return s;
  53 }
  54
  55 static void
  56 sdb_engine_iterator_node_instance_init (SymbolDBEngineIteratorNode *object)
  57 {
  58         SymbolDBEngineIteratorNode *sdbin;
  59 /*      DEBUG_PRINT ("sdb_engine_iterator_node_instance_init ()");*/
  60
  61         sdbin = SYMBOL_DB_ENGINE_ITERATOR_NODE (object);
  62
  63         sdbin->priv = g_new0 (SymbolDBEngineIteratorNodePriv, 1);
  64         sdbin->priv->sym_type_conversion_hash = NULL;
  65         sdbin->priv->uri = NULL;
  66 }
  67
  68 static void
  69 sdb_engine_iterator_node_finalize (GObject *object)
  70 {
  71         /* TODO: Add deinitalization code here */
  72         SymbolDBEngineIteratorNode *dbin;
  73         SymbolDBEngineIteratorNodePriv *priv;
  74
  75 /*      DEBUG_PRINT ("sdb_engine_iterator_node_finalize ()");*/
  76
  77         dbin = SYMBOL_DB_ENGINE_ITERATOR_NODE (object);
  78         priv = dbin->priv;
  79         if (priv->uri)
  80                 g_free (priv->uri);
  81
  82         g_free (priv);
  83
  84         G_OBJECT_CLASS (parent_class)->finalize (object);
  85 }
  86
  87 static void
  88 sdb_engine_iterator_node_class_init (SymbolDBEngineIteratorNodeClass *klass)
  89 {
  90         GObjectClass* object_class = G_OBJECT_CLASS (klass);
  91         parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
  92
  93         object_class->finalize = sdb_engine_iterator_node_finalize;
  94 }
  95
  96 /**
  97  * Symbol name must be always on column 0
  98  */
  99 gint
 100 symbol_db_engine_iterator_node_get_symbol_id (SymbolDBEngineIteratorNode *dbin)
 101 {
 102         SymbolDBEngineIteratorNodePriv *priv;
 103         const GValue* value;
 104         GdaParameter *par;
 105
 106         g_return_val_if_fail (dbin != NULL, -1);
 107         priv = dbin->priv;
 108
 109         par = gda_data_model_iter_get_param_for_column (priv->data_iter, 0);
 110         value = gda_parameter_get_value (par);
 111
 112         return value != NULL && G_VALUE_HOLDS_INT (value)
 113                 ? g_value_get_int (value) : -1;
 114 }
 115
 116 /**
 117  * Symbol name must be always on column 1
 118  */
 119 const gchar*
 120 symbol_db_engine_iterator_node_get_symbol_name (SymbolDBEngineIteratorNode *dbin)
 121 {
 122         SymbolDBEngineIteratorNodePriv *priv;
 123         const GValue* value;
 124         GdaParameter *par;
 125
 126         g_return_val_if_fail (dbin != NULL, NULL);
 127         priv = dbin->priv;
 128
 129         par = gda_data_model_iter_get_param_for_column (priv->data_iter, 1);
 130         value = gda_parameter_get_value (par);
 131
 132         return value != NULL && G_VALUE_HOLDS_STRING (value)
 133                 ? g_value_get_string (value) : NULL;
 134 }
 135
 136 /**
 137  * File pos must be always on column 2
 138  */
 139 gint
 140 symbol_db_engine_iterator_node_get_symbol_file_pos (SymbolDBEngineIteratorNode *dbin)
 141 {
 142         SymbolDBEngineIteratorNodePriv *priv;
 143         const GValue* value;
 144         GdaParameter *par;
 145
 146         g_return_val_if_fail (dbin != NULL, -1);
 147         priv = dbin->priv;
 148
 149         par = gda_data_model_iter_get_param_for_column (priv->data_iter, 2);
 150         value = gda_parameter_get_value (par);
 151
 152         return value != NULL && G_VALUE_HOLDS_INT (value)
 153                 ? g_value_get_int (value) : -1;
 154 }
 155
 156 /**
 157  * 'Is File Scope' must be always on column 3
 158  */
 159 gboolean
 160 symbol_db_engine_iterator_node_get_symbol_is_file_scope (SymbolDBEngineIteratorNode *dbin)
 161 {
 162         SymbolDBEngineIteratorNodePriv *priv;
 163         const GValue* value;
 164
 165         GdaParameter *par;
 166
 167         g_return_val_if_fail (dbin != NULL, FALSE);
 168         priv = dbin->priv;
 169
 170         par = gda_data_model_iter_get_param_for_column (priv->data_iter, 3);
 171         value = gda_parameter_get_value (par);
 172
 173         if (value != NULL)
 174                 return g_value_get_int (value) == 1 ? TRUE : FALSE;
 175
 176         return FALSE;
 177 }
 178
 179 /**
 180  * Signature must be always on column 4
 181  */
 182 const gchar*
 183 symbol_db_engine_iterator_node_get_symbol_signature (SymbolDBEngineIteratorNode *dbin)
 184 {
 185         SymbolDBEngineIteratorNodePriv *priv;
 186         const GValue* value;
 187         GdaParameter *par;
 188
 189         g_return_val_if_fail (dbin != NULL, NULL);
 190         priv = dbin->priv;
 191
 192         par = gda_data_model_iter_get_param_for_column (priv->data_iter, 4);
 193         value = gda_parameter_get_value (par);
 194
 195         return value != NULL && G_VALUE_HOLDS_STRING (value)
 196                 ? g_value_get_string (value) : NULL;
 197 }
 198
 199 const gchar*
 200 symbol_db_engine_iterator_node_get_symbol_extra_string (SymbolDBEngineIteratorNode *dbin,
 201                                                                                                    gint sym_info)
 202 {
 203         SymbolDBEngineIteratorNodePriv *priv;
 204         GdaParameter *par = NULL;
 205         GdaParameter *res = NULL;
 206         gint column = -1;
 207
 208         g_return_val_if_fail (dbin != NULL, NULL);
 209         priv = dbin->priv;
 210 #if 0
 211         DEBUG_PRINT ("symbol_db_engine_iterator_node_get_symbol_extra_string () for %d",
 212                                  sym_info);
 213
 214         if (GDA_PARAMETER_LIST(priv->data_iter)) {
 215                 g_print ("-Parameter(s):\n");
 216                 GSList *params;
 217                 for (params = GDA_PARAMETER_LIST(priv->data_iter)->parameters; params;
 218                          params = params->next) {
 219                         GdaParameter *parameter = GDA_PARAMETER (params->data);
 220                         g_print ("   - name:%s type:%s\n",
 221                                  gda_object_get_name (GDA_OBJECT (parameter)),
 222                                  g_type_name (gda_parameter_get_g_type (parameter)));
 223                 }
 224         }
 225 #endif
 226         if (sym_info & SYMINFO_FILE_PATH)
 227         {
 228                 par = gda_parameter_list_find_param (GDA_PARAMETER_LIST(priv->data_iter),
 229                                                                                          "file_path");
 230         }
 231         else if (sym_info & SYMINFO_LANGUAGE)
 232         {
 233                 par = gda_parameter_list_find_param (GDA_PARAMETER_LIST(priv->data_iter),
 234                                                                                          "language_name");
 235         }
 236         else if (sym_info & SYMINFO_IMPLEMENTATION)
 237         {
 238                 par = gda_parameter_list_find_param (GDA_PARAMETER_LIST(priv->data_iter),
 239                                                                                          "implementation_name");
 240         }
 241         else if (sym_info & SYMINFO_ACCESS)
 242         {
 243                 par = gda_parameter_list_find_param (GDA_PARAMETER_LIST(priv->data_iter),
 244                                                                                          "access_name");
 245         }
 246         else if (sym_info & SYMINFO_KIND)
 247         {
 248                 par = gda_parameter_list_find_param (GDA_PARAMETER_LIST(priv->data_iter),
 249                                                                                          "kind_name");
 250         }
 251         else if (sym_info & SYMINFO_TYPE)
 252         {
 253                 par = gda_parameter_list_find_param (GDA_PARAMETER_LIST(priv->data_iter),
 254                                                                                          "type");
 255         }
 256         else if (sym_info & SYMINFO_TYPE_NAME)
 257         {
 258                 par = gda_parameter_list_find_param (GDA_PARAMETER_LIST(priv->data_iter),
 259                                                                                          "type_name");
 260         }
 261         else if (sym_info & SYMINFO_PROJECT_NAME)
 262         {
 263                 par = gda_parameter_list_find_param (GDA_PARAMETER_LIST(priv->data_iter),
 264                                                                                          "project_name");
 265         }
 266         else if (sym_info & SYMINFO_FILE_IGNORE)
 267         {
 268                 par = gda_parameter_list_find_param (GDA_PARAMETER_LIST(priv->data_iter),
 269                                                                                          "file_ignore_type");
 270         }
 271         else if (sym_info & SYMINFO_FILE_INCLUDE)
 272         {
 273                 par = gda_parameter_list_find_param (GDA_PARAMETER_LIST(priv->data_iter),
 274                                                                                          "file_include_type");
 275         }
 276
 277         if (par != NULL)
 278         {
 279                 column = gda_data_model_iter_get_column_for_param (priv->data_iter, par);
 280                 res = gda_data_model_iter_get_param_for_column (priv->data_iter, column);
 281                 return gda_parameter_get_value_str (res);
 282         }
 283         else
 284                 return NULL;
 285 }
 286
 287 void
 288 symbol_db_engine_iterator_node_set_conversion_hash (SymbolDBEngineIteratorNode *dbin,
 289                                                                                  const GHashTable *sym_type_conversion_hash)
 290 {
 291         g_return_if_fail (dbin != NULL);
 292         g_return_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR_NODE (dbin));
 293
 294         SymbolDBEngineIteratorNodePriv *priv;
 295
 296         priv = dbin->priv;
 297         priv->sym_type_conversion_hash = sym_type_conversion_hash;
 298 }
 299
 300 void
 301 symbol_db_engine_iterator_node_set_data (SymbolDBEngineIteratorNode *dbin,
 302                                                                                  const GdaDataModelIter *data)
 303 {
 304         g_return_if_fail (dbin != NULL);
 305         g_return_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR_NODE (dbin));
 306
 307         SymbolDBEngineIteratorNodePriv *priv;
 308
 309         priv = dbin->priv;
 310         priv->data_iter = GDA_DATA_MODEL_ITER (data);
 311         if (priv->uri != NULL)
 312         {
 313                 g_free (priv->uri);
 314                 priv->uri = NULL;
 315         }
 316 }
 317
 318
 319 /* IAnjutaSymbol implementation */
 320 static IAnjutaSymbolType
 321 isymbol_type (IAnjutaSymbol *isymbol, GError **err)
 322 {
 323         SymbolDBEngineIteratorNode *s;
 324         SymbolDBEngineIteratorNodePriv *priv;
 325         gpointer tag_found;
 326         const gchar* find_str;
 327
 328         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR_NODE (isymbol),
 329                                                   IANJUTA_SYMBOL_TYPE_UNDEF);
 330
 331         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 332         priv = s->priv;
 333
 334         find_str = symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 335                                                                                                    SYMINFO_TYPE);
 336         if (find_str == NULL) {
 337                 DEBUG_PRINT ("isymbol_type (): find_str is NULL");
 338                 return IANJUTA_SYMBOL_TYPE_UNDEF;
 339         }
 340
 341         tag_found = g_hash_table_lookup (priv->sym_type_conversion_hash, find_str);
 342
 343         if (tag_found == NULL) {
 344                 DEBUG_PRINT ("isymbol_type (): nothing matching ");
 345                 return IANJUTA_SYMBOL_TYPE_UNDEF;
 346         }
 347
 348         return (IAnjutaSymbolType)tag_found;
 349 }
 350
 351
 352 static const gchar*
 353 isymbol_type_str (IAnjutaSymbol *isymbol, GError **err)
 354 {
 355         SymbolDBEngineIteratorNode *s;
 356
 357         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol),  NULL);
 358         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 359         return symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 360                                                                 SYMINFO_TYPE);
 361 }
 362
 363 static const gchar*
 364 isymbol_type_name (IAnjutaSymbol *isymbol, GError **err)
 365 {
 366         SymbolDBEngineIteratorNode *s;
 367
 368         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol),  NULL);
 369         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 370         return symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 371                                                                 SYMINFO_TYPE_NAME);
 372 }
 373
 374
 375 static const gchar*
 376 isymbol_name (IAnjutaSymbol *isymbol, GError **err)
 377 {
 378         SymbolDBEngineIteratorNode *s;
 379
 380         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol), NULL);
 381         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 382
 383         return symbol_db_engine_iterator_node_get_symbol_name (s);
 384 }
 385
 386 static const gchar*
 387 isymbol_args (IAnjutaSymbol *isymbol, GError **err)
 388 {
 389         SymbolDBEngineIteratorNode *s;
 390
 391         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol),  NULL);
 392         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 393         return symbol_db_engine_iterator_node_get_symbol_signature (s);
 394 }
 395
 396 static const gchar*
 397 isymbol_scope (IAnjutaSymbol *isymbol, GError **err)
 398 {
 399         SymbolDBEngineIteratorNode *s;
 400
 401         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol),  NULL);
 402         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 403 //      g_return_val_if_fail (s->priv->tm_tag != NULL, NULL);
 404 //      return s->priv->tm_tag->atts.entry.scope;
 405         return NULL;
 406 }
 407
 408 static const gchar*
 409 isymbol_inheritance (IAnjutaSymbol *isymbol, GError **err)
 410 {
 411         SymbolDBEngineIteratorNode *s;
 412
 413         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol),  NULL);
 414         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 415 //      g_return_val_if_fail (s->priv->tm_tag != NULL, NULL);
 416 //      return s->priv->tm_tag->atts.entry.inheritance;
 417 //      return
 418         return NULL;
 419 }
 420
 421 static const gchar*
 422 isymbol_access (IAnjutaSymbol *isymbol, GError **err)
 423 {
 424         SymbolDBEngineIteratorNode *s;
 425
 426         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol), NULL);
 427         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 428         return symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 429                                                                                                                                 SYMINFO_ACCESS);
 430 }
 431
 432 static const gchar*
 433 isymbol_impl (IAnjutaSymbol *isymbol, GError **err)
 434 {
 435         SymbolDBEngineIteratorNode *s;
 436
 437         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol), NULL);
 438         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 439         return symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 440                                                                                                         SYMINFO_IMPLEMENTATION);
 441 }
 442
 443 static const gchar*
 444 isymbol_uri (IAnjutaSymbol *isymbol, GError **err)
 445 {
 446         SymbolDBEngineIteratorNode *s;
 447
 448         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol),  NULL);
 449         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 450         if (s->priv->uri == NULL)
 451         {
 452                 const cgchar* file_path;
 453                 file_path = symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 454                                                                                                         SYMINFO_FILE_PATH);
 455                 s->priv->uri = gnome_vfs_get_uri_from_local_path (file_path);
 456         }
 457         return s->priv->uri;
 458 }
 459
 460 static gulong
 461 isymbol_line (IAnjutaSymbol *isymbol, GError **err)
 462 {
 463         SymbolDBEngineIteratorNode *s;
 464
 465         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol), 0);
 466         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 467         return symbol_db_engine_iterator_node_get_symbol_file_pos (s);
 468 }
 469
 470 static gboolean
 471 isymbol_is_local (IAnjutaSymbol *isymbol, GError **err)
 472 {
 473         SymbolDBEngineIteratorNode *s;
 474
 475         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol), FALSE);
 476         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 477         return symbol_db_engine_iterator_node_get_symbol_is_file_scope (s);
 478 }
 479
 480 static const GdkPixbuf*
 481 isymbol_icon (IAnjutaSymbol *isymbol, GError **err)
 482 {
 483         SymbolDBEngineIteratorNode *s;
 484
 485         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol), FALSE);
 486         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 487
 488         return symbol_db_view_get_pixbuf (
 489                                 symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 490                                                                 SYMINFO_TYPE),
 491                                 symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 492                                                                 SYMINFO_ACCESS));
 493 }
 494
 495 static void
 496 isymbol_iface_init (IAnjutaSymbolIface *iface)
 497 {
 498         iface->type = isymbol_type;
 499         iface->type_str = isymbol_type_str;
 500         iface->type_name = isymbol_type_name;
 501         iface->name = isymbol_name;
 502         iface->args = isymbol_args;
 503         iface->scope = isymbol_scope;
 504         iface->inheritance = isymbol_inheritance;
 505         iface->access = isymbol_access;
 506         iface->impl = isymbol_impl;
 507         iface->uri = isymbol_uri;
 508         iface->line = isymbol_line;
 509         iface->is_local = isymbol_is_local;
 510         iface->icon = isymbol_icon;
 511 }
 512
 513 ANJUTA_TYPE_BEGIN (SymbolDBEngineIteratorNode, sdb_engine_iterator_node, G_TYPE_OBJECT);
 514 ANJUTA_TYPE_ADD_INTERFACE (isymbol, IANJUTA_TYPE_SYMBOL);
 515 ANJUTA_TYPE_END;
 516