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 #include <libgnomevfs/gnome-vfs.h>
  29
  30 #include "symbol-db-engine-iterator-node.h"
  31 #include "symbol-db-engine.h"
  32 #include "symbol-db-view.h"
  33
  34 struct _SymbolDBEngineIteratorNodePriv
  35 {
  36         GdaDataModelIter *data_iter;
  37         const GHashTable *sym_type_conversion_hash;
  38         gchar *uri;
  39 };
  40
  41 static GObjectClass* parent_class = NULL;
  42
  43
  44 SymbolDBEngineIteratorNode *
  45 symbol_db_engine_iterator_node_new (const GdaDataModelIter *data)
  46 {
  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
  60         sdbin = SYMBOL_DB_ENGINE_ITERATOR_NODE (object);
  61
  62         sdbin->priv = g_new0 (SymbolDBEngineIteratorNodePriv, 1);
  63         sdbin->priv->sym_type_conversion_hash = NULL;
  64         sdbin->priv->uri = NULL;
  65 }
  66
  67 static void
  68 sdb_engine_iterator_node_finalize (GObject *object)
  69 {
  70         SymbolDBEngineIteratorNode *dbin;
  71         SymbolDBEngineIteratorNodePriv *priv;
  72
  73         dbin = SYMBOL_DB_ENGINE_ITERATOR_NODE (object);
  74         priv = dbin->priv;
  75         if (priv->uri)
  76                 g_free (priv->uri);
  77
  78         g_free (priv);
  79
  80         G_OBJECT_CLASS (parent_class)->finalize (object);
  81 }
  82
  83 static void
  84 sdb_engine_iterator_node_class_init (SymbolDBEngineIteratorNodeClass *klass)
  85 {
  86         GObjectClass* object_class = G_OBJECT_CLASS (klass);
  87         parent_class = G_OBJECT_CLASS (g_type_class_peek_parent (klass));
  88
  89         object_class->finalize = sdb_engine_iterator_node_finalize;
  90 }
  91
  92 /**
  93  * Symbol name must be always on column 0
  94  */
  95 gint
  96 symbol_db_engine_iterator_node_get_symbol_id (SymbolDBEngineIteratorNode *dbin)
  97 {
  98         SymbolDBEngineIteratorNodePriv *priv;
  99         const GValue* value;
 100
 101         g_return_val_if_fail (dbin != NULL, -1);
 102         priv = dbin->priv;
 103
 104         value = gda_data_model_iter_get_value_at (priv->data_iter, 0);
 105
 106         return value != NULL && G_VALUE_HOLDS_INT (value)
 107                 ? g_value_get_int (value) : -1;
 108 }
 109
 110 /**
 111  * Symbol name must be always on column 1
 112  */
 113 const gchar*
 114 symbol_db_engine_iterator_node_get_symbol_name (SymbolDBEngineIteratorNode *dbin)
 115 {
 116         SymbolDBEngineIteratorNodePriv *priv;
 117         const GValue* value;
 118
 119         g_return_val_if_fail (dbin != NULL, NULL);
 120         priv = dbin->priv;
 121
 122         value = gda_data_model_iter_get_value_at (priv->data_iter, 1);
 123
 124         return value != NULL && G_VALUE_HOLDS_STRING (value)
 125                 ? g_value_get_string (value) : NULL;
 126 }
 127
 128 /**
 129  * File pos must be always on column 2
 130  */
 131 gint
 132 symbol_db_engine_iterator_node_get_symbol_file_pos (SymbolDBEngineIteratorNode *dbin)
 133 {
 134         SymbolDBEngineIteratorNodePriv *priv;
 135         const GValue* value;
 136
 137         g_return_val_if_fail (dbin != NULL, -1);
 138         priv = dbin->priv;
 139
 140         value = gda_data_model_iter_get_value_at (priv->data_iter, 2);
 141
 142         return value != NULL && G_VALUE_HOLDS_INT (value)
 143                 ? g_value_get_int (value) : -1;
 144 }
 145
 146 /**
 147  * 'Is File Scope' must be always on column 3
 148  */
 149 gboolean
 150 symbol_db_engine_iterator_node_get_symbol_is_file_scope (SymbolDBEngineIteratorNode *dbin)
 151 {
 152         SymbolDBEngineIteratorNodePriv *priv;
 153         const GValue* value;
 154
 155         g_return_val_if_fail (dbin != NULL, FALSE);
 156         priv = dbin->priv;
 157
 158         value = gda_data_model_iter_get_value_at (priv->data_iter, 3);
 159
 160         if (value != NULL && G_VALUE_HOLDS_INT (value))
 161                 return g_value_get_int (value) == 1 ? TRUE : FALSE;
 162
 163         return FALSE;
 164 }
 165
 166 /**
 167  * Signature must be always on column 4
 168  */
 169 const gchar*
 170 symbol_db_engine_iterator_node_get_symbol_signature (SymbolDBEngineIteratorNode *dbin)
 171 {
 172         SymbolDBEngineIteratorNodePriv *priv;
 173         const GValue* value;
 174
 175         g_return_val_if_fail (dbin != NULL, NULL);
 176         priv = dbin->priv;
 177
 178         value = gda_data_model_iter_get_value_at (priv->data_iter, 4);
 179
 180         return value != NULL && G_VALUE_HOLDS_STRING (value)
 181                 ? g_value_get_string (value) : NULL;
 182 }
 183
 184 const gchar*
 185 symbol_db_engine_iterator_node_get_symbol_extra_string (SymbolDBEngineIteratorNode *dbin,
 186                                                                                                    gint sym_info)
 187 {
 188         SymbolDBEngineIteratorNodePriv *priv;
 189         const GValue *value = NULL;
 190
 191         g_return_val_if_fail (dbin != NULL, NULL);
 192         priv = dbin->priv;
 193
 194         if (sym_info & SYMINFO_FILE_PATH)
 195         {
 196                 value = gda_data_model_iter_get_value_for_field (priv->data_iter,
 197                                                                                                                  "file_path");
 198         }
 199         else if (sym_info & SYMINFO_LANGUAGE)
 200         {
 201                 value = gda_data_model_iter_get_value_for_field (priv->data_iter,
 202                                                                                                                  "language_name");
 203         }
 204         else if (sym_info & SYMINFO_IMPLEMENTATION)
 205         {
 206                 value = gda_data_model_iter_get_value_for_field (priv->data_iter,
 207                                                                                                                  "implementation_name");
 208         }
 209         else if (sym_info & SYMINFO_ACCESS)
 210         {
 211                 value = gda_data_model_iter_get_value_for_field (priv->data_iter,
 212                                                                                                                  "access_name");
 213         }
 214         else if (sym_info & SYMINFO_KIND)
 215         {
 216                 value = gda_data_model_iter_get_value_for_field (priv->data_iter,
 217                                                                                                                  "kind_name");
 218         }
 219         else if (sym_info & SYMINFO_TYPE)
 220         {
 221                 value = gda_data_model_iter_get_value_for_field (priv->data_iter,
 222                                                                                                                  "type_type");
 223         }
 224         else if (sym_info & SYMINFO_TYPE_NAME)
 225         {
 226                 value = gda_data_model_iter_get_value_for_field (priv->data_iter,
 227                                                                                                                  "type_name");
 228         }
 229         else if (sym_info & SYMINFO_PROJECT_NAME)
 230         {
 231                 value = gda_data_model_iter_get_value_for_field (priv->data_iter,
 232                                                                                                                  "project_name");
 233         }
 234         else if (sym_info & SYMINFO_FILE_IGNORE)
 235         {
 236                 value = gda_data_model_iter_get_value_for_field (priv->data_iter,
 237                                                                                                                  "file_ignore_type");
 238         }
 239         else if (sym_info & SYMINFO_FILE_INCLUDE)
 240         {
 241                 value = gda_data_model_iter_get_value_for_field (priv->data_iter,
 242                                                                                                                  "file_include_type");
 243         }
 244
 245         return value != NULL && G_VALUE_HOLDS_STRING (value)
 246                 ? g_value_get_string (value) : NULL;
 247 }
 248
 249 void
 250 symbol_db_engine_iterator_node_set_conversion_hash (SymbolDBEngineIteratorNode *dbin,
 251                                                                                  const GHashTable *sym_type_conversion_hash)
 252 {
 253         g_return_if_fail (dbin != NULL);
 254         g_return_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR_NODE (dbin));
 255
 256         SymbolDBEngineIteratorNodePriv *priv;
 257
 258         priv = dbin->priv;
 259         priv->sym_type_conversion_hash = sym_type_conversion_hash;
 260 }
 261
 262 void
 263 symbol_db_engine_iterator_node_set_data (SymbolDBEngineIteratorNode *dbin,
 264                                                                                  const GdaDataModelIter *data)
 265 {
 266         g_return_if_fail (dbin != NULL);
 267         g_return_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR_NODE (dbin));
 268
 269         SymbolDBEngineIteratorNodePriv *priv;
 270
 271         priv = dbin->priv;
 272         priv->data_iter = GDA_DATA_MODEL_ITER (data);
 273         if (priv->uri != NULL)
 274         {
 275                 g_free (priv->uri);
 276                 priv->uri = NULL;
 277         }
 278 }
 279
 280 /* IAnjutaSymbol implementation */
 281 static const gchar*
 282 isymbol_get_name (IAnjutaSymbol *isymbol, GError **err)
 283 {
 284         SymbolDBEngineIteratorNode *s;
 285
 286         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol), NULL);
 287         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 288
 289         return symbol_db_engine_iterator_node_get_symbol_name (s);
 290 }
 291
 292 static const gchar*
 293 isymbol_get_args (IAnjutaSymbol *isymbol, GError **err)
 294 {
 295         SymbolDBEngineIteratorNode *s;
 296
 297         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol),  NULL);
 298         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 299         return symbol_db_engine_iterator_node_get_symbol_signature (s);
 300 }
 301
 302 static const gchar*
 303 isymbol_get_extra_info_string (IAnjutaSymbol *isymbol, IAnjutaSymbolField sym_info,
 304                                                            GError **err)
 305 {
 306         SymbolDBEngineIteratorNode *s;
 307
 308         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol), NULL);
 309         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 310         return symbol_db_engine_iterator_node_get_symbol_extra_string (s, sym_info);
 311 }
 312
 313 static GFile*
 314 isymbol_get_file (IAnjutaSymbol *isymbol, GError **err)
 315 {
 316         SymbolDBEngineIteratorNode *s;
 317
 318         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol),  NULL);
 319         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 320         if (s->priv->uri == NULL)
 321         {
 322                 const gchar* file_path;
 323                 GFile* file;
 324                 file_path = symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 325                                                                                                         SYMINFO_FILE_PATH);
 326                 file = g_file_new_for_path (file_path);
 327                 s->priv->uri = g_file_get_uri (file);
 328                 g_object_unref (file);
 329         }
 330         return g_file_new_for_uri (s->priv->uri);
 331 }
 332
 333 static gulong
 334 isymbol_get_line (IAnjutaSymbol *isymbol, GError **err)
 335 {
 336         SymbolDBEngineIteratorNode *s;
 337
 338         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol), 0);
 339         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 340         return symbol_db_engine_iterator_node_get_symbol_file_pos (s);
 341 }
 342
 343 static gboolean
 344 isymbol_is_local (IAnjutaSymbol *isymbol, GError **err)
 345 {
 346         SymbolDBEngineIteratorNode *s;
 347
 348         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol), FALSE);
 349         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 350         return symbol_db_engine_iterator_node_get_symbol_is_file_scope (s);
 351 }
 352
 353 static const GdkPixbuf*
 354 isymbol_get_icon (IAnjutaSymbol *isymbol, GError **err)
 355 {
 356         SymbolDBEngineIteratorNode *s;
 357
 358         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol), FALSE);
 359         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 360
 361         return symbol_db_view_get_pixbuf (
 362                                 symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 363                                                                 SYMINFO_TYPE),
 364                                 symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 365                                                                 SYMINFO_ACCESS));
 366 }
 367
 368 static IAnjutaSymbolType
 369 isymbol_get_sym_type (IAnjutaSymbol *isymbol, GError **err)
 370 {
 371         SymbolDBEngineIteratorNode *s;
 372         SymbolDBEngineIteratorNodePriv *priv;
 373         const gchar* type_str;
 374         gint type;
 375
 376         g_return_val_if_fail (SYMBOL_IS_DB_ENGINE_ITERATOR (isymbol),
 377                                                   IANJUTA_SYMBOL_TYPE_UNDEF);
 378         s = SYMBOL_DB_ENGINE_ITERATOR_NODE (isymbol);
 379
 380         priv = s->priv;
 381
 382         type_str = symbol_db_engine_iterator_node_get_symbol_extra_string (s,
 383                                                                                                    IANJUTA_SYMBOL_FIELD_TYPE);
 384         if (type_str == NULL)
 385                 return IANJUTA_SYMBOL_TYPE_UNDEF;
 386
 387         type = (IAnjutaSymbolType)g_hash_table_lookup ((GHashTable*)priv->sym_type_conversion_hash,
 388                                                                           type_str);
 389
 390         return type;
 391 }
 392
 393 static void
 394 isymbol_iface_init (IAnjutaSymbolIface *iface)
 395 {
 396         iface->get_file = isymbol_get_file;
 397         iface->get_name = isymbol_get_name;
 398         iface->get_line = isymbol_get_line;
 399         iface->get_sym_type = isymbol_get_sym_type;
 400         iface->is_local = isymbol_is_local;
 401         iface->get_args = isymbol_get_args;
 402         iface->get_extra_info_string = isymbol_get_extra_info_string;
 403         iface->get_icon = isymbol_get_icon;
 404 }
 405
 406 ANJUTA_TYPE_BEGIN (SymbolDBEngineIteratorNode, sdb_engine_iterator_node, G_TYPE_OBJECT);
 407 ANJUTA_TYPE_ADD_INTERFACE (isymbol, IANJUTA_TYPE_SYMBOL);
 408 ANJUTA_TYPE_END;
 409