plugins/symbol-db/symbol-db-engine-iterator.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-iterable.h>
  26 #include <libanjuta/anjuta-utils.h>
  27 #include <libanjuta/anjuta-debug.h>
  28 #include "symbol-db-engine-iterator-node.h"
  29 #include "symbol-db-engine-iterator.h"
  30 #include "symbol-db-engine.h"
  31
  32 struct _SymbolDBEngineIteratorPriv
  33 {
  34         GdaDataModel *data_model;
  35         GdaDataModelIter *data_iter;
  36
  37         gint total_rows;
  38 };
  39
  40 static SymbolDBEngineIteratorNodeClass* parent_class = NULL;
  41
  42 static void
  43 sdb_engine_iterator_instance_init (SymbolDBEngineIterator *object)
  44 {
  45         SymbolDBEngineIterator *sdbi;
  46
  47         sdbi = SYMBOL_DB_ENGINE_ITERATOR (object);
  48         sdbi->priv = g_new0 (SymbolDBEngineIteratorPriv, 1);
  49
  50         /* initialize some priv data */
  51         sdbi->priv->data_model = NULL;
  52         sdbi->priv->data_iter = NULL;
  53         sdbi->priv->total_rows = -1;
  54 }
  55
  56 static void
  57 sdb_engine_iterator_finalize (GObject *object)
  58 {
  59         SymbolDBEngineIterator *dbi;
  60         SymbolDBEngineIteratorPriv *priv;
  61
  62         dbi = SYMBOL_DB_ENGINE_ITERATOR (object);
  63         priv = dbi->priv;
  64
  65         if (priv->data_model)
  66                 g_object_unref (priv->data_model);
  67
  68         g_free (priv);
  69         G_OBJECT_CLASS (parent_class)->finalize (object);
  70 }
  71
  72 static void
  73 sdb_engine_iterator_class_init (SymbolDBEngineIteratorClass *klass)
  74 {
  75         GObjectClass* object_class = G_OBJECT_CLASS (klass);
  76         parent_class = g_type_class_ref (SYMBOL_TYPE_DB_ENGINE_ITERATOR_NODE);
  77
  78         object_class->finalize = sdb_engine_iterator_finalize;
  79 }
  80
  81 SymbolDBEngineIterator *
  82 symbol_db_engine_iterator_new (GdaDataModel *model)
  83 {
  84         SymbolDBEngineIterator *dbi;
  85         SymbolDBEngineIteratorPriv *priv;
  86
  87         g_return_val_if_fail (model != NULL, NULL);
  88
  89         dbi = g_object_new (SYMBOL_TYPE_DB_ENGINE_ITERATOR, NULL);
  90
  91         priv = dbi->priv;
  92
  93         priv->data_model = model;
  94         priv->data_iter = gda_data_model_iter_new (model);
  95
  96         /* because gda_data_model_get_n_rows () could be cpu-intensive, we'll
  97          * proxy this value, e.g. it's calculated if it is really needed */
  98         priv->total_rows = -1;
  99
 100         /* to avoid calling everytime this function when we want to use the IteratorNode,
 101          * just do it now.
 102          */
 103         symbol_db_engine_iterator_first (dbi);
 104
 105         /* set the data_iter no the base class */
 106         symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (dbi),
 107                                                                                          priv->data_iter);
 108
 109         ianjuta_iterable_first (IANJUTA_ITERABLE (dbi), NULL);
 110         return dbi;
 111 }
 112
 113 /**
 114  * Set the iterator at the first node.
 115  */
 116 gboolean
 117 symbol_db_engine_iterator_first (SymbolDBEngineIterator *dbi)
 118 {
 119         SymbolDBEngineIteratorPriv *priv;
 120
 121         g_return_val_if_fail (dbi != NULL, FALSE);
 122         priv = dbi->priv;
 123
 124         return gda_data_model_iter_set_at_row (priv->data_iter, 0);
 125 }
 126
 127
 128 gboolean
 129 symbol_db_engine_iterator_move_next (SymbolDBEngineIterator *dbi)
 130 {
 131         SymbolDBEngineIteratorPriv *priv;
 132
 133         g_return_val_if_fail (dbi != NULL, FALSE);
 134         priv = dbi->priv;
 135
 136         return gda_data_model_iter_move_next (priv->data_iter);
 137 }
 138
 139 gboolean
 140 symbol_db_engine_iterator_move_prev (SymbolDBEngineIterator *dbi)
 141 {
 142         SymbolDBEngineIteratorPriv *priv;
 143
 144         g_return_val_if_fail (dbi != NULL, FALSE);
 145         priv = dbi->priv;
 146
 147         return gda_data_model_iter_move_prev (priv->data_iter);
 148 }
 149
 150 /**
 151  * @return -1 on error
 152  */
 153 gint
 154 symbol_db_engine_iterator_get_n_items (SymbolDBEngineIterator *dbi)
 155 {
 156         SymbolDBEngineIteratorPriv *priv;
 157
 158         g_return_val_if_fail (dbi != NULL, -1);
 159         priv = dbi->priv;
 160
 161         if (priv->total_rows < 0)
 162         {
 163                 /* try to get the number of rows */
 164                 priv->total_rows = gda_data_model_get_n_rows (priv->data_model);
 165         }
 166
 167         return priv->total_rows;
 168 }
 169
 170 /**
 171  * Set the iterator at the last node.
 172  */
 173 gboolean
 174 symbol_db_engine_iterator_last (SymbolDBEngineIterator *dbi)
 175 {
 176         SymbolDBEngineIteratorPriv *priv;
 177
 178         g_return_val_if_fail (dbi != NULL, FALSE);
 179         priv = dbi->priv;
 180
 181         return gda_data_model_iter_set_at_row (priv->data_iter,
 182                                         symbol_db_engine_iterator_get_n_items (dbi));
 183 }
 184
 185 gboolean
 186 symbol_db_engine_iterator_set_position (SymbolDBEngineIterator *dbi, gint pos)
 187 {
 188         SymbolDBEngineIteratorPriv *priv;
 189
 190         g_return_val_if_fail (dbi != NULL, FALSE);
 191         priv = dbi->priv;
 192
 193         return gda_data_model_iter_set_at_row (priv->data_iter, pos);
 194 }
 195
 196 gint
 197 symbol_db_engine_iterator_get_position (SymbolDBEngineIterator *dbi)
 198 {
 199         SymbolDBEngineIteratorPriv *priv;
 200
 201         g_return_val_if_fail (dbi != NULL, FALSE);
 202         priv = dbi->priv;
 203
 204         return gda_data_model_iter_get_row (priv->data_iter);
 205 }
 206
 207
 208 void
 209 symbol_db_engine_iterator_foreach (SymbolDBEngineIterator *dbi, GFunc callback,
 210                                                                    gpointer user_data)
 211 {
 212         SymbolDBEngineIteratorPriv *priv;
 213
 214         g_return_if_fail (dbi != NULL);
 215         priv = dbi->priv;
 216
 217         gint saved_pos = symbol_db_engine_iterator_get_position (dbi);
 218
 219         symbol_db_engine_iterator_last (dbi);
 220
 221         while (!symbol_db_engine_iterator_move_next (dbi))
 222                 callback (dbi, user_data);
 223         symbol_db_engine_iterator_set_position (dbi, saved_pos);
 224 }
 225
 226 /* IAnjutaIterable implementation */
 227
 228 static gboolean
 229 isymbol_iter_first (IAnjutaIterable *iterable, GError **err)
 230 {
 231         SymbolDBEngineIterator *dbi = SYMBOL_DB_ENGINE_ITERATOR (iterable);
 232         SymbolDBEngineIteratorPriv *priv;
 233
 234         g_return_val_if_fail (dbi != NULL, FALSE);
 235         priv = dbi->priv;
 236
 237
 238         if (symbol_db_engine_iterator_first (dbi) == FALSE)
 239         {
 240                 symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (iterable),
 241                                                                                  NULL);
 242
 243                 return FALSE;
 244         }
 245         symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (iterable),
 246                                                                                  priv->data_iter);
 247         return TRUE;
 248 }
 249
 250 static gboolean
 251 isymbol_iter_next (IAnjutaIterable *iterable, GError **err)
 252 {
 253         SymbolDBEngineIterator *dbi = SYMBOL_DB_ENGINE_ITERATOR (iterable);
 254         SymbolDBEngineIteratorPriv *priv;
 255
 256         g_return_val_if_fail (dbi != NULL, FALSE);
 257         priv = dbi->priv;
 258
 259         if (symbol_db_engine_iterator_move_next (dbi) == FALSE)
 260         {
 261                 symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (iterable),
 262                                                                                  NULL);
 263
 264                 return FALSE;
 265         }
 266         symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (iterable),
 267                                                                                  priv->data_iter);
 268
 269         return TRUE;
 270 }
 271
 272 static gboolean
 273 isymbol_iter_previous (IAnjutaIterable *iterable, GError **err)
 274 {
 275         SymbolDBEngineIterator *dbi = SYMBOL_DB_ENGINE_ITERATOR (iterable);
 276         SymbolDBEngineIteratorPriv *priv;
 277
 278         g_return_val_if_fail (dbi != NULL, FALSE);
 279         priv = dbi->priv;
 280
 281         if (symbol_db_engine_iterator_move_prev (dbi) == FALSE)
 282         {
 283                 symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (iterable),
 284                                                                                  NULL);
 285
 286                 return FALSE;
 287         }
 288         symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (iterable),
 289                                                                                  priv->data_iter);
 290
 291         return TRUE;
 292 }
 293
 294 static gboolean
 295 isymbol_iter_last (IAnjutaIterable *iterable, GError **err)
 296 {
 297         SymbolDBEngineIterator *dbi = SYMBOL_DB_ENGINE_ITERATOR (iterable);
 298         SymbolDBEngineIteratorPriv *priv;
 299
 300         g_return_val_if_fail (dbi != NULL, FALSE);
 301         priv = dbi->priv;
 302
 303         if (symbol_db_engine_iterator_last (dbi) == FALSE)
 304         {
 305                 symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (iterable),
 306                                                                                  NULL);
 307
 308                 return FALSE;
 309         }
 310         symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (iterable),
 311                                                                                  priv->data_iter);
 312
 313         return TRUE;
 314 }
 315
 316 static void
 317 isymbol_iter_foreach (IAnjutaIterable *iterable, GFunc callback,
 318                                           gpointer user_data, GError **err)
 319 {
 320         SymbolDBEngineIterator *dbi = SYMBOL_DB_ENGINE_ITERATOR (iterable);
 321         SymbolDBEngineIteratorPriv *priv;
 322
 323         g_return_if_fail (dbi != NULL);
 324         priv = dbi->priv;
 325
 326         symbol_db_engine_iterator_foreach (dbi, callback, user_data);
 327 }
 328
 329 static gboolean
 330 isymbol_iter_set_position (IAnjutaIterable *iterable,
 331                                                    gint position, GError **err)
 332 {
 333         SymbolDBEngineIterator *dbi = SYMBOL_DB_ENGINE_ITERATOR (iterable);
 334         SymbolDBEngineIteratorPriv *priv;
 335
 336         g_return_val_if_fail (dbi != NULL, FALSE);
 337         priv = dbi->priv;
 338
 339         if (symbol_db_engine_iterator_set_position (dbi, position) == FALSE)
 340         {
 341                 symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (iterable),
 342                                                                                  NULL);
 343
 344                 return FALSE;
 345         }
 346         symbol_db_engine_iterator_node_set_data (SYMBOL_DB_ENGINE_ITERATOR_NODE (iterable),
 347                                                                                  priv->data_iter);
 348
 349         return TRUE;
 350 }
 351
 352 static gint
 353 isymbol_iter_get_position (IAnjutaIterable *iterable, GError **err)
 354 {
 355         SymbolDBEngineIterator *dbi = SYMBOL_DB_ENGINE_ITERATOR (iterable);
 356         SymbolDBEngineIteratorPriv *priv;
 357
 358         g_return_val_if_fail (dbi != NULL, FALSE);
 359         priv = dbi->priv;
 360
 361         return symbol_db_engine_iterator_get_position (dbi);
 362 }
 363
 364 static gint
 365 isymbol_iter_get_length (IAnjutaIterable *iterable, GError **err)
 366 {
 367         SymbolDBEngineIterator *dbi = SYMBOL_DB_ENGINE_ITERATOR (iterable);
 368         SymbolDBEngineIteratorPriv *priv;
 369
 370         g_return_val_if_fail (dbi != NULL, FALSE);
 371         priv = dbi->priv;
 372
 373         return symbol_db_engine_iterator_get_n_items (dbi);
 374 }
 375
 376 static IAnjutaIterable *
 377 isymbol_iter_clone (IAnjutaIterable *iter, GError **e)
 378 {
 379         DEBUG_PRINT ("isymbol_iter_clone  () UNIMPLEMENTED");
 380         return NULL;
 381 }
 382
 383 static void
 384 isymbol_iter_assign (IAnjutaIterable *iter, IAnjutaIterable *src_iter, GError **e)
 385 {
 386         DEBUG_PRINT ("isymbol_iter_assign () UNIMPLEMENTED");
 387 }
 388
 389
 390 static void
 391 isymbol_iter_iface_init (IAnjutaIterableIface *iface, GError **err)
 392 {
 393         iface->first = isymbol_iter_first;
 394         iface->next = isymbol_iter_next;
 395         iface->previous = isymbol_iter_previous;
 396         iface->last = isymbol_iter_last;
 397         iface->foreach = isymbol_iter_foreach;
 398         iface->set_position = isymbol_iter_set_position;
 399         iface->get_position = isymbol_iter_get_position;
 400         iface->get_length = isymbol_iter_get_length;
 401         iface->clone = isymbol_iter_clone;
 402         iface->assign = isymbol_iter_assign;
 403 }
 404
 405
 406
 407 ANJUTA_TYPE_BEGIN (SymbolDBEngineIterator, sdb_engine_iterator, SYMBOL_TYPE_DB_ENGINE_ITERATOR_NODE);
 408 ANJUTA_TYPE_ADD_INTERFACE (isymbol_iter, IANJUTA_TYPE_ITERABLE);
 409 ANJUTA_TYPE_END;