• configuration object path (like D-Bus paths): namespace:/path/to/object

• preference: attribute of the object at the configuration object path

Low level API

• GConfigBackend: interface for database backends
  • multiple backends
  • loadable modules
  • each backend has the base path it's been assigned by the user via configuration file
  • each backend has a set, a get, a list preferences and a list paths method, all accepting paths
• GConfigSource: remote object for database objects
  • remote object
  • loads the backend needed for the namespace+path
  • registers a filter function on the bus
  • holds a counter for the number of factories (proxies) it has
  • if the counter reaches 0, unrefs the backend
• GConfigFactory: local object for database objects
  • bound to a namespace+path
  • loads the schema object
  • validates data when setting (fails if not valid)
  • validates data when getting (fails if not valid, returns the schema default)
  • changes notification: GSignal "changed" for every change, "changed::preference" for the changes of "preference"
  • multiple factories for the same configuration path map to a single source
• GConfigSchema: shallow object for a schema (from file, buffer or in-code)
  • can be created from scratch and assigned to a factory
  • can be created from a file or a buffer and assigned to a factory

API usage examples

• get two preferences from the applications:/org/gnome/Test configuration object:

  GConfigFactory *factory;
  gchar *foo;
  gint bar;

  factory = g_config_get_applications_factory ("/org/gnome/Test", "test.schemas");
  g_config_factory_get (factory, "foo", &foo, "bar", &bar, NULL);
  
  g_object_unref (factory);

• set a preference of the applications:/org/gnome/Test configuration object, with direct error reporting:

  if (!g_config_factory_set_preference (factory, "bar", new_bar))
    {
      GError *error;
      g_config_factory_get_error (factory, &error);
      g_warning ("Error: %s", error->message);
      g_error_free (error); 
    }

• set a preference with indirect error reporting:

  static void
  on_error_cb (GConfigFactory *factory,
               const GError   *error,
               gpointer        user_data)
  {
    ...
  }
  ...
  g_signal_connect (factory, "error", G_CALLBACK (on_error_cb), NULL);
  g_config_factory_set (factory, "bar", new_bar, NULL);

• change notification:

  static void
  on_foo_changed_cb (GConfigFactory *factory,
                     const gchar    *preference, /* "foo" */
                     GConfigSchema  *schema,
                     gpointer        user_data)
  {
    gchar *foo;

    g_config_factory_get (factory, preference, &foo, NULL);
  }
  ...
  g_signal_connect (factory, "changed::foo", G_CALLBACK (on_foo_changed_cb), NULL);

Configuration

• gconfig resource file (similar to gtkrc, parsed by GScanner)

• define namespaces, define backends

  namespace "applications" {
    readable = TRUE
    writable = TRUE
    backend "file" {
      base_path "$HOME/.gconfig/applications"
    }
  }

  namespace "system" {
    readable = TRUE
    writable = TRUE
    backend "bdb" {
      base_path "$HOME/.gconfig/system"
    }
  }

• all the defaults are stored inside schemas files
• administrators must override a schema, not a value inside the database

  schema "org.gnome.Foo" {
    # override the file containing the schema
    path "/etc/gconfig/local/our-foo"
  }

  schema "org.gnome.Bar" {
    # override a preference - a schema for org.gnome.Bar/baz *must* exist
    preference "baz" {
      type = "int"
      value = 42
    }
  }

Schemas

• FIXME

Backends

• current backends: file (keyfile-based), dummy (in-memory table)

Namespaces