gtkD/srcgda/gda/Config.d

   1 /*
   2  * This file is part of gtkD.
   3  *
   4  * gtkD is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU Lesser General Public License as published by
   6  * the Free Software Foundation; either version 2.1 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * gtkD is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public License
  15  * along with gtkD; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19 // generated automatically - do not change
  20 // find conversion definition on APILookup.txt
  21 // implement new conversion functionalities on the wrap.utils pakage
  22
  23 /*
  24  * Conversion parameters:
  25  * inFile  = libgda-gda-config.html
  26  * outPack = gda
  27  * outFile = Config
  28  * strct   =
  29  * realStrct=
  30  * ctorStrct=
  31  * clss    = Config
  32  * interf  =
  33  * class Code: No
  34  * interface Code: No
  35  * template for:
  36  * extend  =
  37  * implements:
  38  * prefixes:
  39  *      - gda_config_
  40  * omit structs:
  41  *      - GdaDataSourceInfo
  42  *      - GdaProviderInfo
  43  * omit prefixes:
  44  *      - gda_data_source_
  45  *      - gda_provider_
  46  * omit code:
  47  * imports:
  48  *      - glib.ListG
  49  * structWrap:
  50  *      - GList* -> ListG
  51  *      - GdaDataSourceInfo -> DataSourceInfo
  52  * module aliases:
  53  * local aliases:
  54  */
  55
  56 module gda.Config;
  57
  58 version(noAssert)
  59 {
  60         version(Tango)
  61         {
  62                 import tango.io.Stdout; // use the tango loging?
  63         }
  64 }
  65
  66 private import gdac.gdatypes;
  67
  68 private import gdac.gda;
  69
  70
  71 private import glib.ListG;
  72
  73
  74
  75
  76 /**
  77  * Description
  78  *  The functions in this section allow applications an easy access to the libgda
  79  *  configuration, thus making them able to access the list of data sources
  80  *  configured in the system, for instance.
  81  */
  82 public class Config
  83 {
  84
  85         /**
  86          */
  87
  88         /**
  89          * Gets the value of the specified configuration entry as a string. You
  90          * are then responsible to free the returned string.
  91          * path :
  92          *  path to the configuration entry.
  93          * Returns :
  94          *  the value stored at the given entry.
  95          */
  96         public static char[] getString(char[] path)
  97         {
  98                 // gchar* gda_config_get_string (const gchar *path);
  99                 return Str.toString(gda_config_get_string(Str.toStringz(path)) );
 100         }
 101
 102         /**
 103          * Gets the value of the specified configuration entry as an integer.
 104          * path :
 105          *  path to the configuration entry.
 106          * Returns :
 107          *  the value stored at the given entry.
 108          */
 109         public static int getInt(char[] path)
 110         {
 111                 // gint gda_config_get_int (const gchar *path);
 112                 return gda_config_get_int(Str.toStringz(path));
 113         }
 114
 115         /**
 116          * Gets the value of the specified configuration entry as a float.
 117          * path :
 118          *  path to the configuration entry.
 119          * Returns :
 120          *  the value stored at the given entry.
 121          */
 122         public static double getFloat(char[] path)
 123         {
 124                 // gdouble gda_config_get_float (const gchar *path);
 125                 return gda_config_get_float(Str.toStringz(path));
 126         }
 127
 128         /**
 129          * Gets the value of the specified configuration entry as a boolean.
 130          * path :
 131          *  path to the configuration entry.
 132          * Returns :
 133          *  the value stored at the given entry.
 134          */
 135         public static int getBoolean(char[] path)
 136         {
 137                 // gboolean gda_config_get_boolean (const gchar *path);
 138                 return gda_config_get_boolean(Str.toStringz(path));
 139         }
 140
 141         /**
 142          * Sets the given configuration entry to contain a string.
 143          * path :
 144          *  path to the configuration entry.
 145          * new_value :
 146          *  new value.
 147          */
 148         public static void setString(char[] path, char[] newValue)
 149         {
 150                 // void gda_config_set_string (const gchar *path,  const gchar *new_value);
 151                 gda_config_set_string(Str.toStringz(path), Str.toStringz(newValue));
 152         }
 153
 154         /**
 155          * Sets the given configuration entry to contain an integer.
 156          * path :
 157          *  path to the configuration entry.
 158          * new_value :
 159          *  new value.
 160          */
 161         public static void setInt(char[] path, int newValue)
 162         {
 163                 // void gda_config_set_int (const gchar *path,  gint new_value);
 164                 gda_config_set_int(Str.toStringz(path), newValue);
 165         }
 166
 167         /**
 168          * Sets the given configuration entry to contain a float.
 169          * path :
 170          *  path to the configuration entry.
 171          * new_value :
 172          *  new value.
 173          */
 174         public static void setFloat(char[] path, double newValue)
 175         {
 176                 // void gda_config_set_float (const gchar *path,  gdouble new_value);
 177                 gda_config_set_float(Str.toStringz(path), newValue);
 178         }
 179
 180         /**
 181          * Sets the given configuration entry to contain a boolean.
 182          * path :
 183          *  path to the configuration entry.
 184          * new_value :
 185          *  new value.
 186          */
 187         public static void setBoolean(char[] path, int newValue)
 188         {
 189                 // void gda_config_set_boolean (const gchar *path,  gboolean new_value);
 190                 gda_config_set_boolean(Str.toStringz(path), newValue);
 191         }
 192
 193         /**
 194          * Removes the given section from the configuration database.
 195          * path :
 196          *  path to the configuration section.
 197          */
 198         public static void removeSection(char[] path)
 199         {
 200                 // void gda_config_remove_section (const gchar *path);
 201                 gda_config_remove_section(Str.toStringz(path));
 202         }
 203
 204         /**
 205          * Removes the given entry from the configuration database.
 206          * If the section is empty, also remove the section.
 207          * path :
 208          *  path to the configuration entry.
 209          */
 210         public static void removeKey(char[] path)
 211         {
 212                 // void gda_config_remove_key (const gchar *path);
 213                 gda_config_remove_key(Str.toStringz(path));
 214         }
 215
 216         /**
 217          * Checks whether the given section exists in the configuration
 218          * system.
 219          * path :
 220          *  path to the configuration section.
 221          * Returns :
 222          *  TRUE if the section exists, FALSE otherwise.
 223          */
 224         public static int hasSection(char[] path)
 225         {
 226                 // gboolean gda_config_has_section (const gchar *path);
 227                 return gda_config_has_section(Str.toStringz(path));
 228         }
 229
 230         /**
 231          * Checks whether the given key exists in the configuration system.
 232          * path :
 233          *  path to the configuration key.
 234          * Returns :
 235          *  TRUE if the entry exists, FALSE otherwise.
 236          */
 237         public static int hasKey(char[] path)
 238         {
 239                 // gboolean gda_config_has_key (const gchar *path);
 240                 return gda_config_has_key(Str.toStringz(path));
 241         }
 242
 243         /**
 244          * Returns a GList containing the names of all the sections available
 245          * under the given root directory.
 246          * To free the returned value, you can use gda_config_free_list.
 247          * path :
 248          *  path for root dir.
 249          * Returns :
 250          *  a list containing all the section names.
 251          */
 252         public static ListG listSections(char[] path)
 253         {
 254                 // GList* gda_config_list_sections (const gchar *path);
 255                 return new ListG( gda_config_list_sections(Str.toStringz(path)) );
 256         }
 257
 258         /**
 259          * Returns a list of all keys that exist under the given path.
 260          * To free the returned value, you can use gda_config_free_list.
 261          * path :
 262          *  path for root dir.
 263          * Returns :
 264          *  a list containing all the key names.
 265          */
 266         public static ListG listKeys(char[] path)
 267         {
 268                 // GList* gda_config_list_keys (const gchar *path);
 269                 return new ListG( gda_config_list_keys(Str.toStringz(path)) );
 270         }
 271
 272         /**
 273          * Gets a string representing the type of the value of the given key.
 274          * The caller is responsible of freeing the returned value.
 275          * path :
 276          *  path to the configuration key.
 277          * Returns :
 278          *  NULL if not found. Otherwise: "string", "float", "long", "bool".
 279          */
 280         public static char[] getType(char[] path)
 281         {
 282                 // gchar* gda_config_get_type (const gchar *path);
 283                 return Str.toString(gda_config_get_type(Str.toStringz(path)) );
 284         }
 285
 286         /**
 287          * Frees all memory used by the given GList, which must be the return value
 288          * from either gda_config_list_sections and gda_config_list_keys.
 289          * list :
 290          *  list to be freed.
 291          */
 292         public static void freeList(ListG list)
 293         {
 294                 // void gda_config_free_list (GList *list);
 295                 gda_config_free_list((list is null) ? null : list.getListGStruct());
 296         }
 297
 298
 299         /**
 300          * Installs a configuration listener, which is a callback function
 301          * which will be called every time a change occurs on a given
 302          * configuration entry.
 303          * path :
 304          *  configuration path to listen to.
 305          * func :
 306          *  callback function.
 307          * user_data :
 308          *  data to be passed to the callback function.
 309          * Returns :
 310          *  the ID of the listener, which you will need for
 311          * calling gda_config_remove_listener. If an error occurs,
 312          * 0 is returned.
 313          */
 314         public static uint addListener(char[] path, GdaConfigListenerFunc func, void* userData)
 315         {
 316                 // guint gda_config_add_listener (const gchar *path,  GdaConfigListenerFunc func,  gpointer user_data);
 317                 return gda_config_add_listener(Str.toStringz(path), func, userData);
 318         }
 319
 320         /**
 321          * Removes a configuration listener previously installed with
 322          * gda_config_add_listener, given its ID.
 323          * id :
 324          *  the ID of the listener to remove.
 325          */
 326         public static void removeListener(uint id)
 327         {
 328                 // void gda_config_remove_listener (guint id);
 329                 gda_config_remove_listener(id);
 330         }
 331
 332
 333
 334
 335
 336
 337         /**
 338          * Returns a list of all providers currently installed in
 339          * the system. Each of the nodes in the returned GList
 340          * is a GdaProviderInfo. To free the returned list,
 341          * call the gda_config_free_provider_list function.
 342          * Returns :
 343          *  a GList of GdaProviderInfo structures.
 344          */
 345         public static ListG getProviderList()
 346         {
 347                 // GList* gda_config_get_provider_list (void);
 348                 return new ListG( gda_config_get_provider_list() );
 349         }
 350
 351         /**
 352          * Frees a list of GdaProviderInfo structures.
 353          * list :
 354          *  the list to be freed.
 355          */
 356         public static void freeProviderList(ListG list)
 357         {
 358                 // void gda_config_free_provider_list (GList *list);
 359                 gda_config_free_provider_list((list is null) ? null : list.getListGStruct());
 360         }
 361
 362         /**
 363          * Gets a GdaProviderInfo structure from the provider list given its name.
 364          * name :
 365          *  name of the provider to search for.
 366          * Returns :
 367          *  a GdaProviderInfo structure, if found, or NULL if not found.
 368          */
 369         public static GdaProviderInfo* getProviderByName(char[] name)
 370         {
 371                 // GdaProviderInfo* gda_config_get_provider_by_name (const gchar *name);
 372                 return gda_config_get_provider_by_name(Str.toStringz(name));
 373         }
 374
 375         /**
 376          * Fills and returns a new GdaDataModel object using information from all
 377          * providers which are currently installed in the system.
 378          * Rows are separated in 3 columns:
 379          * 'Id', 'Location' and 'Description'.
 380          * Returns :
 381          *  a new GdaDataModel object.
 382          */
 383         public static GdaDataModel* getProviderModel()
 384         {
 385                 // GdaDataModel* gda_config_get_provider_model (void);
 386                 return gda_config_get_provider_model();
 387         }
 388
 389
 390
 391
 392         /**
 393          * Creates a new GdaDataSourceInfo structure from an existing one.
 394          * src :
 395          *  data source information to get a copy from.
 396          * Returns :
 397          *  a newly allocated GdaDataSourceInfo with contains a copy of
 398          * information in src.
 399          */
 400         public static GdaDataSourceInfo* copyDataSourceInfo(GdaDataSourceInfo* src)
 401         {
 402                 // GdaDataSourceInfo* gda_config_copy_data_source_info (GdaDataSourceInfo *src);
 403                 return gda_config_copy_data_source_info(src);
 404         }
 405
 406         /**
 407          * Deallocates all memory associated to the given GdaDataSourceInfo.
 408          * info :
 409          *  data source information to free.
 410          */
 411         public static void freeDataSourceInfo(GdaDataSourceInfo* info)
 412         {
 413                 // void gda_config_free_data_source_info (GdaDataSourceInfo *info);
 414                 gda_config_free_data_source_info(info);
 415         }
 416
 417         /**
 418          * Returns a list of all data sources currently configured in the system.
 419          * Each of the nodes in the returned GList is a GdaDataSourceInfo.
 420          * To free the returned list, call the gda_config_free_data_source_list
 421          * function.
 422          * Returns :
 423          *  a GList of GdaDataSourceInfo structures.
 424          */
 425         public static ListG getDataSourceList()
 426         {
 427                 // GList* gda_config_get_data_source_list (void);
 428                 return new ListG( gda_config_get_data_source_list() );
 429         }
 430
 431         /**
 432          * Gets a GdaDataSourceInfo structure from the data source list given its
 433          * name.
 434          * name :
 435          *  name of the data source to search for.
 436          * Returns :
 437          *  a GdaDataSourceInfo structure, if found, or NULL if not found.
 438          */
 439         public static GdaDataSourceInfo* findDataSource(char[] name)
 440         {
 441                 // GdaDataSourceInfo* gda_config_find_data_source (const gchar *name);
 442                 return gda_config_find_data_source(Str.toStringz(name));
 443         }
 444
 445         /**
 446          * Frees a list of GdaDataSourceInfo structures.
 447          * list :
 448          *  the list to be freed.
 449          */
 450         public static void freeDataSourceList(ListG list)
 451         {
 452                 // void gda_config_free_data_source_list (GList *list);
 453                 gda_config_free_data_source_list((list is null) ? null : list.getListGStruct());
 454         }
 455
 456         /**
 457          * Fills and returns a new GdaDataModel object using information from all
 458          * data sources which are currently configured in the system.
 459          * Rows are separated in 6 columns:
 460          * 'Name', 'Provider', 'Connection string', 'Description', 'Username' and
 461          * 'Password'.
 462          * Returns :
 463          *  a new GdaDataModel object.
 464          */
 465         public static GdaDataModel* getDataSourceModel()
 466         {
 467                 // GdaDataModel* gda_config_get_data_source_model (void);
 468                 return gda_config_get_data_source_model();
 469         }
 470
 471         /**
 472          * Adds a new data source (or update an existing one) to the GDA
 473          * configuration, based on the parameters given.
 474          * name :
 475          *  name for the data source to be saved.
 476          * provider :
 477          *  provider ID for the new data source.
 478          * cnc_string :
 479          *  connection string for the new data source.
 480          * description :
 481          *  description for the new data source.
 482          * username :
 483          *  user name for the new data source.
 484          * password :
 485          *  password to use when authenticating username.
 486          */
 487         public static void saveDataSource(char[] name, char[] provider, char[] cncString, char[] description, char[] username, char[] password)
 488         {
 489                 // void gda_config_save_data_source (const gchar *name,  const gchar *provider,  const gchar *cnc_string,  const gchar *description,  const gchar *username,  const gchar *password);
 490                 gda_config_save_data_source(Str.toStringz(name), Str.toStringz(provider), Str.toStringz(cncString), Str.toStringz(description), Str.toStringz(username), Str.toStringz(password));
 491         }
 492
 493         /**
 494          * Saves a data source in the libgda configuration given a
 495          * GdaDataSourceInfo structure containing all the information
 496          * about the data source.
 497          * dsn_info :
 498          *  a GdaDataSourceInfo structure.
 499          */
 500         public static void saveDataSourceInfo(GdaDataSourceInfo* dsnInfo)
 501         {
 502                 // void gda_config_save_data_source_info (GdaDataSourceInfo *dsn_info);
 503                 gda_config_save_data_source_info(dsnInfo);
 504         }
 505
 506         /**
 507          * Removes the given data source from the GDA configuration.
 508          * name :
 509          *  name for the data source to be removed.
 510          */
 511         public static void removeDataSource(char[] name)
 512         {
 513                 // void gda_config_remove_data_source (const gchar *name);
 514                 gda_config_remove_data_source(Str.toStringz(name));
 515         }
 516
 517
 518
 519
 520 }